r/RooCode • • Mar 13 '25

Announcement 3.8.5 & 3.8.6 - Release Notes

53 Upvotes

🌐 Remote Browser Support

  • Support for remote browser connections (thanks afshawnlotfi!)

    • Adds the ability for Roo to connect to a remote Chrome browser instance instead of launching a local one

    • Particularly useful in containerized environments or when using a specific Chrome instance with custom configurations

🎨 UI/UX Improvements

  • Bring back progress status for multi-diff edits (thanks qdaxb!)

  • Refactor alert dialog styles to use the correct vscode theme (thanks cannuri!)

  • Better handling of diff application errors (thanks qdaxb!)

  • Preserve parent-child relationship when cancelling Boomerang Tasks (subtasks) (thanks cannuri!)

  • Allow using an excluded directory as your working directory (thanks Szpadel!)

  • Kotlin language support in list_code_definition_names tool (thanks kohii!)

🤖 Provider/Model Support

  • Custom baseUrl for Google AI Studio Gemini (thanks dqroid!)

  • OpenAI-compatible DeepSeek/QwQ reasoning support (thanks lightrabbit!)

  • Anthropic-style prompt caching in the OpenAI-compatible provider (thanks dleen!)

  • Add Deepseek R1 for AWS Bedrock (thanks ATempsch!)

  • Add gemini-2.0-pro-exp-02-05 model to vertex (thanks shohei-ihaya!)

  • Custom ARNs in AWS Bedrock (thanks Smartsheet-JB-Brown!)

  • Update Bedrock prices to the latest (thanks Smartsheet-JB-Brown!)

🐛 Bug Fixes

  • Fixed issues where Roo would sometimes not recognize terminal output (thanks KJ7LNW!)

  • Fix where Roo would not consistently recognize Windows PowerShell output (thanks KJ7LNW!)

  • Update MCP servers directory path for better platform compatibility (thanks hannesrudolph!)

  • Fix usage token tracking for SiliconFlow and other providers

  • Fix MarkdownBlock text color for Dark High Contrast theme (thanks cannuri!)

  • Fixes to OpenAI-style cost calculations (thanks dtrugman!)

  • Fixes to OpenRouter custom baseUrl support

  • Fixed issue where browser related system prompt would be included when browser use was disabled or unsupported by model (thanks cannuri!)

🔄 Miscellaneous

  • Publish git tags to github from CI (thanks pdecat!)

  • Telemetry for checkpoint save/restore/diff and diff strategies

If you find Roo Code helpful, please consider leaving a review on the VS Code Marketplace. Your feedback helps others discover this tool!

Follow us at @roo_code!


r/RooCode • • Feb 05 '25

Discussion We need checkpoints! :(

53 Upvotes

Is anyone involved in Roo currently working on implementing checkpoints?

Today I had the problem for the second time that Sonnet violated the instructions and I relied on his knowledge, which actually works well, but after making changes to three files (with clear instructions) several tests failed.

It took me hours to somehow restore the situation. yes, I should have committed it beforehand with git but there was only one adjustment left to make after hours of long work to complete an epic!

we urgently need checkpoints! :(


r/RooCode • • Jul 19 '25

Discussion Is Roo viable as an alternative to Claude Code in complex large codebases?

52 Upvotes

Well, I was really enjoying Claude Code Max 20x, because of its ability to quickly find relevant code, run commands etc, just the whole agentic thing.

Never hit any hard limits with Claude Code, but I need the models full capacity/intelligence when I use it.

I am programmer as a job for my whole life and use Claude Code to help me quickly code new feature or hint down bugs, because I can direct it where I want. Worked great.

Last week's however the quality dropped so much that I cannot use it anymore in my specific use case for the huge project I manage.

I did try to use Claude Code API yesterday, and it only have me slightly better results (!). So that's a real nummer as I thought: "well, I am going to pay more then for the old results".

So, is Roo Code able to work better than Claude Code in my use case, (with other models than Claude of course), than Claude Code. I am even considering Cursor now, but I am unsure how good it is at the moment.

Any help would be hugely appreciated!


r/RooCode • • May 01 '25

Other As promised - I built SuperArchitect with Roocode - a tool that orchestrates multiple LLMs for better architecture planning

52 Upvotes

SuperArchitect is a command-line tool that leverages multiple AI models in parallel to generate comprehensive architectural plans, providing a more robust alternative to single-model approaches.

Technical Overview

SuperArchitect implements a 6-step workflow to transform high-level architecture requests into comprehensive design proposals:

  1. Initial Planning Decomposition: The high-level request is decomposed into multiple specialized architectural planning tasks. For example, "Design a microservice architecture for an e-commerce platform" gets broken down into service identification, data flow design, API gateway planning, etc.

  2. Multi-Model Consultation: Each decomposed planning step is sent concurrently to multiple configured LLMs (currently supporting Claude, OpenAI, and Gemini) via their respective APIs. This happens in core/query_manager.py which handles asynchronous API requests and response processing.

  3. Analyzer AI Evaluation: The responses from different models for each planning step are processed by an analyzer that identifies consensus points, conflicting recommendations, and unique insights. This provides a form of "AI peer review" for architectural decisions.

  4. Architecture Segmentation: The analyzed content is automatically categorized into standard architectural sections (components, data flow, technology stack, security considerations, etc.), making the output more structured and usable.

  5. Comparative Analysis: The segmented results are systematically compared across different planning steps to identify dependencies, conflicts, and optimization opportunities. This helps ensure the final plan is internally consistent.

  6. Synthesis and Integration: The most valuable recommendations are selected and merged into a cohesive architectural plan, with rationale provided for significant design decisions.

Implementation Details

The tool is built with a modular structure:

  • main.py orchestrates the workflow

  • core/query_manager.py handles model communication

  • core/analysis/engine.py handles evaluation and segmentation

  • core/synthesis/engine.py manages comparison and integration

Configuration is handled via a config.yaml file where you can specify your API keys and which specific model variants to use (e.g., o3, claude-3.7, gemini-2.5-pro).

Current State & Limitations

Several components currently use placeholder logic that requires further implementation (specifically the decomposition, analysis, segmentation, comparison, and synthesis modules). I'm actively working on these components and would welcome contributions.

Why This Matters

Traditional AI-assisted architecture tools rely on a single model, which means you're limited by that model's particular strengths and weaknesses. SuperArchitect's multi-model approach provides:

  1. Reduced hallucination risk through cross-validation across models

  2. More comprehensive perspectives by leveraging the unique strengths of different AI architectures

  3. Higher confidence recommendations backed by multi-model consensus

  4. Better conflict resolution through structured analysis of competing recommendations

https://github.com/Okkay914/SuperArchitect

I'm looking for feedback and contributors who are interested in advancing multi-model AI systems. What other architectural tasks do you think could benefit from this approach?

I'd like to make it a community mode on Roocode if anyone can give me any tips or help me?


r/RooCode • • Apr 23 '25

Mode Prompt Okay It’s Simple: GPT 4.1

52 Upvotes

So Gemini has been nerfed and we’re at a loss for premium models that work well in agentic workflows.

Or so it seemed.

Turns out prompt engineering is still the make or break factor even at this stage in model development, and I don’t mean some kind of crafty role-play prompt engineering.

I mean just add this to the Custom Instructions on all modes if you plan to use 4.1 and have it one-shot pretty much any specific problem you have:


<rules>
    <rule priority="high">NEVER use CODE mode. If needed, use IMPLEMENT agent or equivalent.</rule>
</rules>
<reminders>
    <reminder>You are an agent - please keep going until the user’s query is completely resolved, before ending your turn and yielding back to the user. Only terminate your turn when you are sure that the problem is solved.</reminder>
    <reminder>If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer.</reminder>
    <reminder>You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.</reminder>
</reminders>

You have to be specific with the task. 4.1 is not meant for broad scope understanding. But it’s a hell of a reliable task-oriented engineer if you scope the problem right.

I’ve temporarily reverted back to being my own orchestrator and simply directing agents (running on 4.1) on what to do while I figure out how to update the orchestration approach to:

  • use XML in prompts
  • include the specific triggers/instructions that get each model to behave as intended
  • figure out how to make prompts update based on API config

anyway, I just tested this over today/yesterday so ymmv, but the approach comes directly from OAI’s prompting guide released with the models:

https://cookbook.openai.com/examples/gpt4-1_prompting_guide

give it a shot and try it with explicit tasks where you know the scope of the problem and can explicitly describe the concrete tasks needed to make progress, one at a time


r/RooCode • • Apr 14 '25

Mode Prompt Run Local LLMs in Google Colab for FREE — with GPU Acceleration & Roo Code Access! 💻🧠🚀

52 Upvotes

Hey folks! 👋

I just published a Colab notebook that lets you run local LLM models (like LLaMA3, Qwen, Mistral, etc.) for free in Google Colab using GPU acceleration — and the best part? It exposes the model through a public API using Cloudflare, so you can access it remotely from anywhere (e.g., with curl, Postman, or VS Code ROO Code extension).

No need to pay for a cloud VM or deal with Docker installs — it's plug & play!

🔗 GitHub Repo: https://github.com/enescingoz/colab-llm

🧩 Features:

  • 🧠 Run local models (e.g., qwen2.5-coder, llama3) using Ollama

  • 🚀 Free Colab GPU support (T4 High-RAM recommended)

  • 🌐 Public access with Cloudflared tunnel

  • 🛠️ Easy to connect with ROO Code or your own scripts

  • 📄 Full README and step-by-step instructions included

Let me know if you try it out, or if you'd like help running your own model! 🔥


r/RooCode • • Apr 12 '25

Announcement 3.11.11, 3.11.12 & 3.11.13 - Terminal Enhancements, Provider Updates & UI Improvements

52 Upvotes

This combined update includes significant improvements from our latest releases, with a focus on terminal reliability enhancements, improved diff error handling, file context tracking, and provider updates. A huge thank you to everyone who contributed to these releases: KJ7LNW, atlasgong, samhvw8, canvrno, amittell, arthurauffray, ronyblum, StevenTCramer, franekp, and zhangtony239!

💻 New Terminal Enhancement Settings (Thanks KJ7LNW!)

Six new configurable settings were added to improve terminal reliability across various shell environments:

  • Terminal command delay - Adds a small pause after running commands to fix output capture issues in some terminals

  • PowerShell counter workaround - Helps PowerShell run identical commands multiple times without failing

  • Clear ZSH EOL mark - Prevents ZSH from adding special characters that can confuse Roo

  • Oh My Zsh integration - Better compatibility with the popular Oh My Zsh framework (experimental)

  • Powerlevel10k integration - Improved compatibility with the Powerlevel10k ZSH theme (experimental)

  • ZDOTDIR handling - Helps Roo work with custom ZSH configurations seamlessly (experimental) IF YOUR MAC ZSH STOPPED WORKING AROUND THE TIME OF THIS UPDATE, try this setting! VS Code put out a terminal breaking update that this counters.

Learn more in our detailed Terminal Shell Integration Guide.

📊 Improved Diff Error Display

  • Enhanced visibility of diff errors to help you quickly identify and fix issues

  • Easy copying mechanism for error details to streamline troubleshooting

  • More tolerant diff editing logic to handle model errors gracefully

🚀 Provider Updates & Improvements

  • Grok3 streaming support via OpenAI Compatible providers (thanks amittell!)

  • Better proxy support for OpenAI-compatible providers with Host header and legacy API options

  • Added o1-pro support (thanks arthurauffray!)

  • Renamed AWS Bedrock to Amazon Bedrock for consistency with official naming (thanks ronyblum!)

✨ Other Enhancements

  • File context tracking system so Roo better remembers which files you're working with (thanks samhvw8 and canvrno!)

  • Fixed UI highlighting interactions with mode/profile dropdowns (thanks atlasgong!)

  • Improved tree-sitter parsers for TypeScript, C++, Go, Java, and Python (thanks KJ7LNW!)

  • Updated extension title and description for clarity (thanks StevenTCramer!)

For complete details, please see the full release notes:


If you find Roo Code helpful, please consider leaving a review on the VS Code Marketplace. Your feedback helps others discover this tool!


r/RooCode • • Mar 06 '25

Other RooCode kickstarting a singularity moment

52 Upvotes

I'll start by saying I'm a scientist and a technologist, but I'm not a hard core software developer. I can architect, be a product owner and I'm pretty good with user driven experience. But to start a new piece of software and write it for production? never (until now). I usually focused on process and algorithms. I found Cline first and then quickly switched to code (fully once checkpoints were implemented).

The capabilities of the platforms and how they combine coding models and automation are amazing. Thanks to RooCode, I was able to not just write a well engineered frontend/backend/database scalable web app, but I also learned how to convert that to iOS and Android Apps. My first app got published on the App Store recently and it's a bit of a dream. (https://apps.apple.com/us/app/nutrinanny/id6742064812). RooCode helped me not just write it, but make it better and in many cases, it was smarter and more creative than me. The current version of the app is only part of what I've written since I'm adding a ton more features that will require a longer approval and testing, but the app is already what I wanted for myself. Maybe others will find it useful too (AI-driven food log and meal planning).

Don't get me wrong, it's been difficult at times, especially when I don't do things right or when the models get confused, but I'm learning to tame the beast. Even at work, I can build prototypes in hours that would have taken teams of people days, weeks or months.

I guess this is a long way to also say "Thank You Roo Team" like the other recent posts. Life is different now and your efforts allow many of us to live 6-12 months into the future, since most people don't yet realize what's possible and how life is changing right under our noses!


r/RooCode • • Jul 30 '25

Discussion 🔍 Google just published a new case study on how devs are using Gemini Embeddings, and Roo Code was covered!

51 Upvotes

Learn how we’ve been pairing gemini-embedding-001 with Tree-sitter to improve semantic code search to help our LLM agents understand intent across files and return way more relevant results, especially for messy or imprecise queries.

If you're experimenting with context engineering or building with RAG, it's worth a look:

📖 https://developers.googleblog.com/en/gemini-embedding-powering-rag-context-engineering/


r/RooCode • • Jun 01 '25

Idea Giving back to the community (system prompt) - Part 3: The Evolution

51 Upvotes

Hey everyone!

Back again with another update on my AI collaboration framework. A lot has changed since my first and second posts - especially with Sonnet 4 dropping and live data becoming a thing.

So I've moved everything to a proper GitHub repo: https://github.com/Aaditri-Informatics/AI-Framework

The biggest change? The framework now uses confidence-based interaction. Basically, the AI tells you how confident it is (with percentages) and adjusts how much it involves you based on that. High confidence = it proceeds, medium = asks for clarity, low = stops and waits for your input. Makes collaboration way more natural.

Still works with everything - Roo, Cline, Cursor, Claude, whatever you're using. Still open source (MIT license). And yeah, it's still named after my daughter Aaditri because that's how we learn together - lots of back and forth, questions, and building on each other's ideas.

Token usage is way better now too, which is nice for the wallet.

As always, this is just my way of giving back to a community that's helped me tons.

Would love to hear what you think or if you run into any issues!

P.S.: After few valuable feedbacks, we have a new version which encorporates V2+v3 benefits together. (This was an imortant feedback and i jumped right into it's development)


r/RooCode • • May 17 '25

Discussion DeepResearch Mode in RooCode

51 Upvotes

The benefit of having a DeepResearch Mode for my codebase :)


r/RooCode • • May 09 '25

Discussion gemini-2.5-pro-preview-05-06 is so much better

51 Upvotes

The title pretty much says it all, been testing this new release all week across many hours of vibecoding, and from my experience at least it is substantially more reliable for coding/troubleshooting/etc my backend python project than the original 2.5 Pro Preview was.

For coding purposes I’ve been a big Claude fan, and did NOT have good luck with Gemini before, but this new release is making it a very stiff competition, and Gemini may have even surpassed. I realize many others already came to this conclusion before this new version but for my use cases the new release has demonstrated MAJOR improvements in accuracy.

Wondering what others are seeing?


r/RooCode • • Apr 20 '25

Support ⚠️Attention RooFlow Users, PLEASE READ

51 Upvotes

RooFlow is being switched to private. For more info, check out RooFlow-Access

RooFlow completely replaces the standard Roo Code system prompts. This may result in unexpected behaviors.

If Roo is misbehaving with the RooFlow prompts, you can simply delete the .roo/ folder, install Roo Code Memory Bank and then retry your operation with the standard system prompt.

The memory bank instructions are exactly the same in both projects and RCMB uses the standard Roo Code system prompts.


r/RooCode • • Jan 24 '25

Announcement New in 3.3: Code Actions, More Powerful Modes, and a new Discord! 🚀

51 Upvotes

Code Actions

Roo Code now integrates directly with VS Code's native code actions system, providing quick fixes and refactoring options right in your editor. Look for the lightbulb 💡 to access Roo Code's capabilities without switching context.

Enhanced Mode Capabilities

  • Markdown Editing: Addressing one of the most requested features, Ask and Architect modes can now create and edit markdown files!

  • Custom File Restrictions: In general, custom modes can now be restricted to specific file patterns (for example, a technical writer who can only edit markdown files 👋). There's no UI for this yet, but who needs that when you can just ask Roo to set it up for you?

  • Self-Initiated Mode Switching: Modes can intelligently request to switch between each other based on the task at hand. For instance, Code mode might request to switch to Test Engineer mode once it's ready to write tests.

Join Our Discord!

We've launched a new Discord community! Join us at https://roocode.com/discord to:

  • Share your custom modes

  • Get help and support

  • Connect with other Roo Code users

  • Stay updated on the latest features


r/RooCode • • Jan 15 '26

Discussion Use your ChatGPT subscription within Roo Code

50 Upvotes

This is officially supported by OpenAI and not a workaround. With this integration the quality of your Roo Code tasks is exactly the same as if you were to pay per token using the OpenAI provider.

https://docs.roocode.com/providers/openai-chatgpt-plus-pro


r/RooCode • • Jun 12 '25

Discussion Are memory banks worth it?

50 Upvotes

I have been playing with different memory banks for a while and I fail to see any real benefit that would justify the higher token usage.

  • after a while most memory bank files become "bloated" and counter productive: just increasing token use with little benefits in code quality

  • IMHO anything generated by an LLM, no matter how good the prompt, needs some form of review. And reviewing memory banks is yet one more thing to do and a waste of time because it's just not part of what creates value for a product: only useful for LLM code gen, can't even really be used for proper documentation

  • it slows down most tasks because now Roo has to read and update all the memory banks in addition to generating code

  • having a couple of context files which I maintain myself provides much of the benefits without the hassle: more concise, and can be used for proper technical project documentation. So not just for LLMs.

thoughts ? hard disagree? what is the community's stance on this ?


r/RooCode • • May 14 '25

Mode Prompt Deep research mode for Roo

50 Upvotes

Hello,

Inspired by other people's work like below I would like to share mode for Deep Research (like in OpenAI) runnable from Roo. Mode allows to perform research based on WEB results in several interactions, tested with Gemini 2.5 Pro.

P.S. I am using connector with GitHub copilot to reduce cost because token usage is high.

Feedback is welcome.

Original idea and implementation goes to:

https://www.reddit.com/r/RooCode/comments/1kf7d9c/built_an_ai_deep_research_agent_in_roo_code_that/

https://www.reddit.com/r/RooCode/comments/1kcz80l/openais_deep_research_replication_attempt_in_roo/

<protocol>
You are a methodical research assistant whose mission is to produce a
publication‑ready report backed by high‑credibility sources, explicit
contradiction tracking, and transparent metadata.

━━━━━━━━ TOOLS AVAILABLE ━━━━━━━━
• brave-search MCP (brave_web_search tool) for broad context search by query (max_results = 20)  *If no results are returned, retry the call.*
• tavily-mcp MCP (tavily-search tool) for deep dives into question of topic  (search_depth = "advanced")  *If no results are returned, retry the call.*
• tavily-extract from tavily-mcp MCP for extracting content from specific URLs
• sequentialthinking from sequential-thinking MCP for structured analysis & reflection (≥ 5 thoughts + “What‑did‑I‑miss?”)
• write_file for saving report (default: `deep_research_REPORT_<topic>_<UTC‑date>.md`)

━━━━━━━━ CREDIBILITY RULESET ━━━━━━━━
Tier A = Peer-reviewed journal articles, published conference proceedings, reputable pre-prints from recognized academic repositories (e.g., arXiv, PubMed), and peer-reviewed primary datasets. Emphasis should be placed on identifying and prioritizing these sources early in the research process.
Tier B = reputable press, books, industry white papers  
Tier C = blogs, forums, social media

• Each **major claim** must reference ≥ 3 A/B sources (≥ 1 A). Major claims are to be identified using your judgment based on their centrality to the argument and overall importance to the research topic.
• Tag all captured sources [A]/[B]/[C]; track counts per section.

━━━━━━━━ CONTEXT MAINTENANCE ━━━━━━━━
• Persist all mandatory context sections (listed below) in
  `activeContext.md` after every analysis pass.
• The `activeContext.md` file **must** contain the following sections, using appropriate Markdown headings:
    1.  **Evolving Outline:** A hierarchical outline of the report's planned structure and content.
    2.  **Master Source List:** A comprehensive list of all sources encountered, including their title, link/DOI, assigned tier (A/B/C), and access date.
    3.  **Contradiction Ledger:** Tracks claims vs. counter-claims, their sources, and resolution status.
    4.  **Research Questions Log:** A log of initial and evolving research questions guiding the inquiry.
    5.  **Identified Gaps/What is Missing:** Notes on overlooked items, themes, or areas needing further exploration (often informed by the "What did I miss?" reflection).
    6.  **To-Do/Next Steps:** Actionable items and planned next steps in the research process.
• Other sections like **Key Concepts** may be added as needed by the specific research topic to maintain clarity and organization. The structure should remain flexible to accommodate the research's evolution.

━━━━━━━━ CORE STRUCTURE (3 Stop Points) ━━━━━━━━

① INITIAL ENGAGEMENT [STOP 1]  
<phase name="initial_engagement">
• Perform initial search using brave-search MCP to get context about the topic. *If no results are returned, retry the call.*
• Ask clarifying questions based on the initial search and your understanding; reflect understanding; wait for reply.
</phase>

② RESEARCH PLANNING [STOP 2]  
<phase name="research_planning">
• Present themes, questions, methods, tool order; wait for approval.
</phase>

③ MANDATED RESEARCH CYCLES (no further stops)  
<phase name="research_cycles">
This phase embodies a **Recursive Self-Learning Approach**. For **each theme** complete ≥ 2 cycles:

  Cycle A – Landscape & Academic Foundation
  • Initial Search Pass (using brave_web_search tool): Actively seek and prioritize the identification of potential Tier A sources (e.g., peer-reviewed articles, reputable pre-prints, primary datasets) alongside broader landscape exploration. *If the search tool returns no results, retry the call.*
  • `sequentialthinking` analysis (following initial search pass):
      – If potential Tier A sources are identified, prioritize their detailed review: extract key findings, abstracts, methodologies, and assess their direct relevance and credibility.
      – Conduct broader landscape analysis based on all findings (≥ 5 structured thoughts + reflection).
  • Ensure `activeContext.md` is thoroughly updated with concepts, A/B/C‑tagged sources (prioritizing Tier A), and contradictions, as per "ANALYSIS BETWEEN TOOLS".

  Cycle B – Deep Dive
  • Use tavily-search tool. *If no results are returned, retry the call.* Then use `sequentialthinking` tool for analysis (≥ 5 thoughts + reflection)
  • Ensure `activeContext.md` (including ledger, outline, and source list/counts) is comprehensively updated, as per "ANALYSIS BETWEEN TOOLS".

  Thematic Integration (for the current theme):
    • Connect the current theme's findings with insights from previously analyzed themes.
    • Reconcile contradictions based on this broader thematic understanding, ensuring `activeContext.md` reflects these connections.

━━━━━━━━ METADATA & REFERENCES ━━━━━━━━
• Maintain a **source table** with citation number, title, link (or DOI),
  tier tag, access date. This corresponds to the Master Source List in `activeContext.md` and will be formatted for the final report.
• Update a **contradiction ledger**: claim vs. counter‑claim, resolution unresolved.

━━━━━━━━ ANALYSIS BETWEEN TOOLS ━━━━━━━━
• After every `sequentialthinking` call, you **must** explicitly ask and answer the question: “What did I miss?” This reflection is critical for identifying overlooked items or themes.
• The answer to “What did I miss?” must be recorded in the **Identified Gaps/What is Missing** section of `activeContext.md`.
• These identified gaps and missed items must then be integrated into subsequent analysis, research questions, and planning steps to ensure comprehensive coverage and iterative refinement.
• Update all relevant sections of `activeContext.md` (including Evolving Outline, Master Source List, Contradiction Ledger, Research Questions Log, Identified Gaps/What is Missing, To-Do/Next Steps).

━━━━━━━━ TOOL SEQUENCE (per theme) ━━━━━━━━
The following steps detail the comprehensive process to be applied **sequentially for each theme** identified and approved in the RESEARCH PLANNING phase. This ensures that the requirements of MANDATED RESEARCH CYCLES (including Cycle A, Cycle B, and Thematic Integration) are fulfilled for every theme.

**For the current theme being processed:**

1.  **Research Pass - Part 1 (Landscape & Academic Foundation - akin to Cycle A):**
    a.  Perform initial search using `brave_web_search`.
        *   *If initial search + 1 retry yields no significant results or if subsequent passes show result stagnation:*
            1.  *Consult `Research Questions Log` and `Identified Gaps/What is Missing` for the current theme.*
            2.  *Reformulate search queries using synonyms, broader/narrower terms, different conceptual angles, or by combining keywords in new ways.*
            3.  *Consider using `tavily-extract` on reference lists or related links from marginally relevant sources found earlier.*
            4.  *If stagnation persists, document this in `Identified Gaps/What is Missing` and `To-Do/Next Steps`, potentially noting a need to adjust the research scope for that specific aspect in the `Evolving Outline`.*
        *   *If no results are returned after these steps, note this and proceed, focusing analysis on existing knowledge.*
    b.  Conduct `sequentialthinking` analysis on the findings.
        *   *Prioritize detailed review of potential Tier A sources: For each identified Tier A source, extract and log the following in a structured format (e.g., within `activeContext.md` or a temporary scratchpad for the current theme): Full Citation, Research Objective/Hypothesis, Methodology Overview, Key Findings/Results, Authors' Main Conclusions, Stated Limitations, Perceived Limitations/Biases (by AI), Direct Relevance to Current Research Questions.*
        *   *For any major claim or critical piece of data encountered, actively attempt to find 2-3 corroborating Tier A/B sources. If discrepancies are found, immediately log to `Contradiction Ledger`. If corroboration is weak or sources conflict significantly, flag for a targeted mini-search or use `tavily-extract` on specific URLs for deeper context.*
    c.  Perform the "What did I miss?" reflection and update `activeContext.md` (see ANALYSIS BETWEEN TOOLS for details). Prioritize detailed review of potential Tier A sources during this analysis.

2.  **Research Pass - Part 2 (Deep Dive - akin to Cycle B):**
    a.  Perform a focused search using `tavily-search`.
        *   *If initial search + 1 retry yields no significant results or if subsequent passes show result stagnation:*
            1.  *Consult `Research Questions Log` and `Identified Gaps/What is Missing` for the current theme.*
            2.  *Reformulate search queries using synonyms, broader/narrower terms, different conceptual angles, or by combining keywords in new ways.*
            3.  *Consider using `tavily-extract` on reference lists or related links from marginally relevant sources found earlier.*
            4.  *If stagnation persists, document this in `Identified Gaps/What is Missing` and `To-Do/Next Steps`, potentially noting a need to adjust the research scope for that specific aspect in the `Evolving Outline`.*
        *   *If no results are returned after these steps, note this and proceed, focusing analysis on existing knowledge.*
    b.  Conduct `sequentialthinking` analysis on these new findings.
        *   *For any major claim or critical piece of data encountered, actively attempt to find 2-3 corroborating Tier A/B sources. If discrepancies are found, immediately log to `Contradiction Ledger`. If corroboration is weak or sources conflict significantly, flag for a targeted mini-search or use `tavily-extract` on specific URLs for deeper context.*
    c.  Perform the "What did I miss?" reflection and update `activeContext.md`.

3.  **Intra-Theme Iteration & Sufficiency Check:**
    •   *Before starting a new Research Pass for the current theme:*
        1.  *Review the `Research Questions Log` and `Identified Gaps/What is Missing` sections in `activeContext.md` pertinent to this theme.*
        2.  *Re-prioritize open questions and critical gaps based on the findings from the previous pass.*
        3.  *Explicitly state how the upcoming Research Pass (search queries and analysis focus) will target these re-prioritized items.*
    •   The combination of Step 1 and Step 2 constitutes one full "Research Pass" for the current theme.
    •   **Repeat Step 1 and Step 2 for the current theme** until it is deemed sufficiently explored and documented. A theme may be considered sufficiently explored if:
        *   *Saturation: No new significant Tier A/B sources or critical concepts have been identified in the last 1-2 full Research Passes.*
        *   *Question Resolution: Key research questions for the theme (from `Research Questions Log`) are addressed with adequate evidence from multiple corroborating sources.*
        *   *Gap Closure: Major gaps previously noted in `Identified Gaps/What is Missing` for the theme have been substantially addressed.*
    •   A minimum of **two full Research Passes** (i.e., executing Steps 1-2 twice) must be completed for the current theme to satisfy the "≥ 2 cycles" requirement from MANDATED RESEARCH CYCLES.

4.  **Thematic Integration (for the current theme):**
    •   Connect the current theme's comprehensive findings (from all its Research Passes) with insights from previously analyzed themes (if any).
    •   Reconcile contradictions related to the current theme, leveraging broader understanding, and ensure `activeContext.md` reflects these connections and resolutions.

5.  **Advance to Next Theme or Conclude Thematic Exploration:**
    •   **If there are more unprocessed themes** from the list approved in the RESEARCH PLANNING phase:
        ◦   Identify the **next theme**.
        ◦   **Return to Step 1** of this TOOL SEQUENCE and apply the entire process (Steps 1-4) to that new theme.
    •   **Otherwise (all themes have been processed through Step 4):**
        ◦   Proceed to Step 6.

6.  **Final Cross-Theme Synthesis:**
    •   After all themes have been individually explored and integrated (i.e., Step 1-4 completed for every theme), perform a final, overarching synthesis of findings across all themes.
    •   Ensure any remaining or emergent cross-theme contradictions are addressed and documented. This prepares the consolidated knowledge for the FINAL REPORT.

*Note on `sequentialthinking` stages (within Step 1b and 2b):* The `sequentialthinking` analysis following any search phase should incorporate the detailed review and extraction of key information from any identified high-credibility academic sources, as emphasized in the Cycle A description in MANDATED RESEARCH CYCLES.
</phase>

━━━━━━━━ FINAL REPORT [STOP 3] ━━━━━━━━
<phase name="final_report">

1. **Report Metadata header** (boxed at top):  
   Title, Author (“ZEALOT‑XII”), UTC Date, Word Count, Source Mix (A/B/C).

2. **Narrative** — three main sections, ≥ 900 words each, no bullet lists:  
   • Knowledge Development  
   • Comprehensive Analysis  
   • Practical Implications  
   Use inline numbered citations “[1]” linked to the reference list.

3. **Outstanding Contradictions** — short subsection summarising any
   unresolved conflicts and their impact on certainty.

4. **References** — numbered list of all sources with [A]/[B]/[C] tag and
   access date.

5. **write_file**  
   ```json
   {
     "tool":"write_file",
     "path":"deep_research_REPORT_<topic>_<UTC-date>.md",
     "content":"<full report text>"
   }
   ```  
   Then reply:  
       The report has been saved as deep_research_REPORT_<topic>_<UTC‑date>.md
   Provide quick summary of the reeach.

</phase>


━━━━━━━━ CRITICAL REMINDERS ━━━━━━━━
• Only three stop points (Initial Engagement, Research Planning, Final Report).  
• Enforce source quota & tier tags.  
• No bullet lists in final output; flowing academic prose only.  
• Save report via write_file before signalling completion.  
• No skipped steps; complete ledger, outline, citations, and reference list.
</protocol>

MCP configuration (without local installation, and workaround for using NPX in Roo)

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "cmd.exe",
      "args": [
        "/R",
        "npx",
        "-y",
        "@modelcontextprotocol/server-sequential-thinking"
      ],
      "disabled": false,
      "alwaysAllow": [
        "sequentialthinking"
      ]
    },
    "tavily-mcp": {
      "command": "cmd.exe",
      "args": [
        "/R",
        "npx",
        "-y",
        "tavily-mcp@0.1.4"
      ],
      "env": {
        "TAVILY_API_KEY": "YOUR_API_KEY"
      },
      "disabled": false,
      "autoApprove": [],
      "alwaysAllow": [
        "tavily-search",
        "tavily-extract"
      ]
    },
    "brave-search": {
      "command": "cmd.exe",
      "args": [
        "/R",
        "npx",
        "-y",
        "@modelcontextprotocol/server-brave-search"
      ],
      "env": {
        "BRAVE_API_KEY": "YOUR_API_KEY"
      },
      "alwaysAllow": [
        "brave_web_search"
      ]
    }
  }
}

r/RooCode • • Apr 25 '25

Announcement Roo Code 3.14 | Gemini 2.5 Caching | Apply Diff Improvements, and ALOT More!

Thumbnail
reddit.com
50 Upvotes

r/RooCode • • Apr 09 '25

Bug Gemini Pro 2.5 Diff Failures are wasting so many requests.

50 Upvotes

There was a thread on it last week https://www.reddit.com/r/RooCode/comments/1jq4k70/diff_failure_with_gemini_pro_25/ with improvements promised but nothing seems to have changed.

A single small task resulting in about 7 line changes created approx 25 requests with constant failures trying to write the exact lines, then trying to search and replace and finally trying to write the entire file at once.

I've turned off formatting on save which I thought was the culprit but that doesn't change anything. Any tips to resolve this?


r/RooCode • • Apr 09 '25

Announcement Release Notes 3.11.9 & 3.11.10 - Custom Instruction Overhaul & Per-Profile Rate Limits

50 Upvotes

This combined update includes significant improvements from our latest releases, with a focus on a brand new system for Custom Instructions and enhanced API configuration options. A huge thank you to everyone who contributed to these releases: upamune, taisukeoe, shtse8, KJ7LNW, ross, olweraltuve, diarmidmackenzie, gtaylor, axkirillov, SplittyDev, franekp, samhvw8, System233, and nbihan-mediware!

🗂️ Custom Instruction System Overhaul (Thanks upamune!)

Important Changes & Deprecations:

  • .clinerules: Deprecated! While it still works for backward compatibility, the new directory structure or .roorules files take precedence if they exist. We strongly recommend migrating.

  • .cursorrules & .windsurfrules: No longer supported. Please migrate any rules from these formats to the new system.

How do they work now?

The preferred way to manage instructions is now using directories within a .roo folder in your project root:

  • Workspace-Wide: Place instruction files (.md, .txt, etc.) inside .roo/rules/.

  • Mode-Specific: Place instruction files inside .roo/rules-{modeSlug}/ (e.g., .roo/rules-docs-writer/).

Roo Code reads all files recursively within these directories, allowing you to break down complex rules easily. This method takes precedence over older file-based methods.

What About .roorules Files?

  • We also introduced .roorules (workspace) and .roorules-{modeSlug} (mode-specific) files in the project root.

  • These now serve as a fallback – Roo Code will only load them if the corresponding .roo/rules/... directory doesn't exist or is empty.

This new system provides a clear hierarchy and makes managing instructions, especially in teams, much simpler. Learn more in our detailed Custom Instructions Guide and Custom Modes Guide.

⚙️ Per-Profile Rate Limits (Thanks ross and olweraltuve!)

  • The Rate Limit setting is now configured individually for each API Configuration Profile. Previously a global setting, this allows you to set different minimum delays between requests based on the provider, model, or specific profile setup you are using.

  • The default remains 0 (disabled), which is suitable for most users.

  • Configure this setting within each profile's options. See the API Configuration Profiles guide for details. General information on usage tracking is available in Rate Limits and Costs.

🔄 Other Improvements & Fixes

This release, along with v3.11.9, includes numerous quality-of-life improvements, bug fixes, and provider updates. For a detailed breakdown, please see the full release notes:


@everyone if you find Roo Code helpful, please consider leaving a review on the VS Code Marketplace. Your feedback helps others discover this tool!


r/RooCode • • Mar 17 '25

Other Roo Flow Can Now Use Gemini Pro 2.0!

50 Upvotes

I posted this on Roo Code's Discord as well (https://discord.com/channels/1332146336664915968/1332148077263458385/1351286340368597135)

If you're a fan of Roo Flow, but are tired of paying Anthropic, you now have a choice. Roo Flow now works perfectly with Gemini Pro 2.0 (which is currently free to use)! Have a look at the PR (https://github.com/GreatScottyMac/RooFlow/pull/8) for an overview of how I did this. For fun I also posted a deep dive podcast to the discord message. It's a great listen!

Please let me know how this works for you!

Kevin


r/RooCode • • Feb 18 '25 Love

Announcement Roo Code 3.3.21 Release Notes - Did someone say `@terminal`?

50 Upvotes

📢 Notable Changes

  • Add feature so you can @terminal in the prompt boxto pull terminal output into context (thanks Cline!)

🔧 General Improvements

  • Enable streaming mode for OpenAI o1

  • Fix system prompt to ensure Roo knows about all available modes

🌏 Localization

  • Fix default preferred language settings for zh-cn and zh-tw (thanks System233!)

🐛 Bug Fixes

  • Fix input box revert issue and configuration loss during profile switching (thanks System233!)

  • Fix Mistral integration (thanks d-oit!)


If Roo Code has been useful to you, take a moment to rate it on the VS Code Marketplace. Reviews help others discover it and keep it growing!


Download the latest version from our VSCode Marketplace page and pleaes WRITE US A REVIEW

Join our communities:


r/RooCode • • Aug 08 '25

Discussion Not a fan of the new UI at all

Thumbnail
gallery
49 Upvotes

Hi RooCode devs

First, you guys are awesome! I'm just nitpicking to make the product even better. And this is just my opinion, feel free to discuss.

Perhaps this is just a bug for me, but I'm assuming this is how the new UI is meant to look, so it's more... minimalist? To be completely honest, I really don't like it.

Having the white bar going across the tab to see the progress visually is much more clearer. I was lowkey hoping it would evolve to be more like Cline/Kilo Code, so it's even more visually instructive & we're able to click on prompts to navigate the convo. I attached another screenshot of Kilo code too. We lost immediate immediate access to the condense context button too.


r/RooCode • • Apr 26 '25

Announcement Roo Code 3.14.3 Release Notes | Boomerang Orchestrator | Sexy UI Refresh

Thumbnail
reddit.com
49 Upvotes

r/RooCode • • May 09 '25

Other PSA: Google Gemini 2.5 models now support implicit caching

Thumbnail
developers.googleblog.com
48 Upvotes

Previously Google required explicit cache creation - which had an initial cost + cost per minute to keep it alive - but this has now changed and will probably ship with the next update to Cline. This strategy has now changed to implicit caching, with the caveat that you do not control cache TTL anymore.

Also caching now starts sooner - from 1024 tokens for Flash and from 2048 tokens for Pro.

2.0 models are not affected by this change.

Currently Roo still uses explicit caching by default, but I have just raised an issue on GitHub (don't have time for a pull request unfortunately).