CtrlK
Roo Code is an open-source AI coding agent that runs as a Visual Studio Code extension. It gives developers an autonomous assistant capable of reading and writing files, running terminal commands, browsing the web, and coordinating complex multi-step tasks across an entire codebase. The project started as a fork of Cline in late 2024 under the name Roo Cline, then rebranded to Roo Code in early 2025. By the time its original development team announced a shutdown in April 2026, the extension had surpassed 3 million installations on the VS Code Marketplace and accumulated roughly 23,900 GitHub stars.
The feature that most distinguishes Roo Code from its parent project is a structured multi-mode system. Rather than a single agent that handles every request the same way, Roo Code assigns different behavioral profiles to different kinds of work: planning, coding, asking questions, debugging, and custom workflows. Each mode gets a tailored system prompt and a specific set of tool permissions, which keeps the agent focused and reduces unnecessary token usage. This architecture influenced several subsequent forks, most notably Kilo Code.
The project began inside a veterinary staffing technology company called Roo. The original goal was practical: the internal engineering team wanted an AI coding assistant they could configure more precisely than Cline allowed at the time. According to co-founder Danny Leffel, initial feature requests to the Cline maintainer were declined because the changes would add too much complexity to the base project. The Cline maintainer's response was essentially "feel free to fork," so the Roo team did.
The fork was publicly released on the VS Code Marketplace under the name Roo Cline in late 2024, using the same publisher identifier it still carries today (RooVeterinaryInc.roo-cline). Within weeks the project gained traction in the developer community, with early adopters drawn to its per-project instruction support, more granular auto-approval controls, and a richer set of context configuration options.
The Hacker News thread from February 4, 2025, titled "Roo Code (formerly Roo Cline) is a fork of Cline that gets rave reviews," captured the moment the wider developer community started paying attention. Comments in that thread describe the fork emerging specifically from demand for finer-grained configuration options that the original project had declined to add.
As the extension's install count grew past 50,000 and then continued climbing, the team decided the "Roo Cline" name was confusing. It tied the project semantically to Cline, even as the two codebases diverged in significant ways. On January 14, 2025, Danny Leffel published an announcement titled "Introducing Roo Code: The Next Chapter in AI-Driven Development" that formally introduced the new name.
The announcement acknowledged the debt owed to the original Cline project while positioning Roo Code as an independent direction. Leffel wrote that the new name represented the journey the team had been on and the future they were building, while acknowledging how far the fork had already diverged from its origins.
The VS Code Marketplace listing kept the original publisher slug for backward compatibility, but the display name changed to "Roo Code" and the GitHub organization eventually moved to RooCodeInc/Roo-Code.
Through 2025 the project grew rapidly. The release cadence was aggressive, sometimes multiple releases per day. The team added the Roo Code Cloud service, which let autonomous agents run PR reviews and other tasks from GitHub, Slack, or a web browser. The Roo Code Router provided a simplified way to access frontier models from Anthropic, OpenAI, Google, and xAI without managing separate API keys.
Pricing tiers emerged alongside the cloud features. The base extension remained free. A Free cloud tier added token usage tracking. A Pro tier at $20 per month plus $5 per hour for cloud tasks unlocked autonomous cloud agents. A Team tier at $99 per month (no per-seat charges) added centralized billing, shared settings, and unified GitHub and Slack integration.
By early 2026 the extension had crossed 1.58 million VS Code Marketplace installations, with adoption reported at companies including Apple, Microsoft, Amazon, and ByteDance. The GitHub repository had accumulated over 3,200 forks.
On April 21, 2026, co-founder Matt Rubens announced that all Roo Code products would shut down on May 15, 2026. The shutdown covered the VS Code extension, Roo Code Cloud, and Roo Code Router. Any unused account balances would be refunded.
The rationale Rubens gave was forward-looking rather than an admission of failure. Roo Code had hit 3 million total installs. The team was shutting it down to go all-in on Roomote, a cloud-based autonomous agent that integrates directly with Slack, GitHub, and Linear to carry out tasks end-to-end without an IDE. Rubens stated that the company had concluded IDEs are not the future of coding, and continuing to invest in the extension would distract from building the cloud product.
Cline publicly welcomed the Roo Code user base following the announcement. The open-source extension repository was archived, though a community team stepped in to maintain it. The final official release was v3.53.0, published April 23, 2026, which added GPT-5.5 support via OpenAI Codex, Claude Opus 4.7 on Vertex AI, and improved checkpoint navigation controls.
The mode system is the structural center of Roo Code. Every conversation in the extension happens inside a mode, and each mode configures three things: the agent's role definition (a detailed system prompt that describes its personality and area of expertise), the set of tool groups it can access, and any custom instructions that apply only to that mode.
The practical effect is that you can switch from an agent that only reads files and produces architecture diagrams to one with full edit and terminal access, without changing any global settings. Modes are also the unit of model assignment: a feature called sticky models lets each mode remember the last AI model used with it, so an Architect mode can default to a large reasoning model while a Code mode defaults to a faster, cheaper one.
Mode switching happens through a dropdown in the VS Code sidebar or by typing slash commands at the beginning of a message (/architect, /ask, /debug, /code, /orchestrator).
Code mode is the default mode and provides the widest set of capabilities. Its role definition describes it as a skilled software engineer with expertise in programming languages, design patterns, and best practices. It has access to all four tool groups: read (examining files and directories), edit (modifying files), command (running terminal commands), and MCP (interacting with Model Context Protocol servers).
This mode handles the bulk of everyday development work: writing new features, refactoring existing code, running tests, fixing linter errors, and implementing changes described in natural language. Because it has command access, it can also install packages, run build scripts, and interact with external services through the terminal.
Architect mode is read-only except for markdown files. Its role definition frames it as an experienced technical leader who helps design systems and create implementation plans. The restricted tool access is intentional: Architect mode is meant to think and plan without accidentally modifying code during the planning phase.
Typical uses include generating technical specifications, mapping out database schemas, planning refactoring strategies, and creating migration guides. The mode uses a structured approach to information gathering before producing a plan, asking clarifying questions and reading relevant files before making any recommendations. Output tends to be markdown documents: architecture decision records, step-by-step implementation plans, or annotated pseudocode.
The separation between Architect and Code modes mirrors a workflow practice common in larger engineering teams, where design and implementation phases are kept distinct. Users can explicitly switch from Architect to Code mode after a plan is approved, at which point the agent has the full context of what was designed and can begin implementing it.
Ask mode has the most restricted tool access of the four built-in modes. It can read files and interact with MCP servers, but it cannot edit files or execute terminal commands. Its role definition describes it as a knowledgeable technical assistant focused on providing thorough and complete answers.
The mode is designed for learning and exploration without risk of accidental changes. Common uses include asking questions about how parts of a codebase work, getting explanations of unfamiliar libraries or patterns, and generating documentation without applying it. Ask mode frequently produces diagrams as part of its explanations without writing them to the project.
Debug mode has full tool access like Code mode, but its system prompt directs it toward methodical problem diagnosis rather than open-ended implementation. Its role definition frames it as an expert problem solver specializing in systematic troubleshooting and diagnostics.
The default approach is to first analyze the problem, then generate hypotheses about possible causes, then add targeted logging to confirm which hypothesis is correct before proposing a fix. This structured process reduces the tendency of AI coding agents to jump immediately to a solution that treats symptoms rather than underlying causes. Debug mode is particularly useful for intermittent bugs or issues where the failure mode is not immediately obvious from the error message alone.
Orchestrator mode, also called Boomerang mode, coordinates complex multi-step projects by delegating work to other modes through a subtask system. It has intentionally limited direct tool access: it cannot read files, write files, execute commands, or call MCP servers on its own. Its only purpose is coordination.
When Orchestrator mode receives a complex task, it breaks the work into subtasks and delegates each one to whichever mode is most appropriate. Each subtask runs in its own isolated context with its own conversation history. When a subtask finishes, a summary returns to the Orchestrator, which uses that summary to plan the next step. The isolation prevents the parent context from filling up with implementation details like file diffs and command output.
A concrete example: building a new API feature might involve Architect mode generating a specification, Code mode implementing the feature against that specification, Debug mode investigating a failing test, and Code mode again applying the fix. The Orchestrator manages the handoffs. By default, each subtask handoff requires user approval, though this can be turned off for more autonomous operation.
Beyond the five built-in modes, Roo Code allows users to create their own modes with arbitrary role definitions, tool permissions, and custom instructions. Custom modes can be global (available in every project) or project-specific (stored in a .roomodes file in the project root).
Three methods exist for creating custom modes. The simplest is asking the agent to create one in natural language ("Create a mode called Documentation Writer that can only read files and write Markdown"). The second is through a form in the Modes page of the VS Code sidebar. The third is editing YAML or JSON configuration files directly.
Each custom mode requires a slug (a unique identifier), a name, a role definition, and a set of tool groups. Tool access can be restricted not just by group but by file path pattern, using regular expression rules. For example, a Documentation Writer mode might have edit access restricted to files matching \.(md|mdx)$, preventing it from accidentally modifying source code.
Mode-specific instructions can also be stored in a directory structure (.roo/rules-{mode-slug}/) or in a single file (.roorules-{mode-slug}), which keeps per-mode guidance close to the project rather than embedded in configuration.
Custom modes can override the built-in ones. If a project-level .roomodes file defines a mode with the slug code, it replaces the default Code mode for that project. This lets teams standardize on project-specific AI behavior without distributing complex configuration files.
The Roo Code Marketplace offered a gallery of community-created modes for common use cases including React development, test writing, and documentation.
Roo Code is model-agnostic and follows a bring-your-own-key (BYOK) model for most providers. Users connect their own API keys and pay model providers directly. The extension supports more than 25 providers:
| Provider | Notes |
|---|---|
| Anthropic | Claude 3.5, Claude 3.7, Claude Opus 4, and later models |
| OpenAI | GPT-4o, o1, o3, Codex models |
| Google Gemini | Gemini 2.5 Pro, Flash, and Flash Lite |
| Google Vertex AI | GCP-hosted models including Gemini and Claude |
| AWS Bedrock | Claude and other models via Amazon infrastructure |
| DeepSeek | DeepSeek V3 and R1 |
| Mistral AI | Mistral and Codestral models |
| xAI | Grok models |
| OpenRouter | Access to 100+ models via a single key |
| Ollama | Local models running on-device |
| LM Studio | Local model server |
| LiteLLM | Unified proxy for many providers |
| Fireworks AI | Fast inference for open models |
| SambaNova | High-speed inference |
| Requesty | Smart routing with cost optimization |
| Moonshot | Kimi models |
| Vercel AI Gateway | Unified access through Vercel |
| Groq | Fast inference |
| VS Code Language Model API | Models exposed by other VS Code extensions |
| Qwen Code CLI | Alibaba Qwen models |
| Z AI | Additional frontier models |
| HuggingFace | Open model hosting |
| Cerebras | Fast inference provider |
| Chutes | Additional provider |
The Roo Code Router, a managed service that the company operated until the May 2026 shutdown, provided an alternative to managing individual API keys. It offered access to frontier models from Anthropic, OpenAI, Google, and xAI through a single account, with usage billed through the Roo Code Cloud subscription.
Each mode in Roo Code can have its own default model. A common pattern was to use a large reasoning model like Claude Opus or o3 for Architect mode (where quality and depth of reasoning matter more than speed) and a faster, cheaper model like Claude Sonnet or Gemini Flash for Code mode (where responsiveness is more important during iterative implementation).
Roo Code and Cline share a common codebase origin but diverged substantially over the course of 2025. The most significant architectural difference is the mode system. Cline uses a simpler Plan/Act toggle, while Roo Code provides five built-in modes with distinct tool access and system prompts, plus an arbitrary number of custom modes. This gives Roo Code more structured control over agent behavior at the cost of added configuration complexity.
The second major difference is the editing mechanism. Cline rewrites entire files when making changes, which is a safer approach but consumes more output tokens. Roo Code uses a diff-based editing method that outputs only the changed lines. For a 500-line file with 10 changed lines, this can reduce edit costs by roughly 30% compared to full-file rewrites. Independent testing placed the cost difference at approximately $0.0003 per edit for Roo Code versus $0.0075 per edit for Cline on a file of that size using Claude Sonnet.
Context specification differs as well. Cline indexes the repository at startup to map file relationships and dependencies, which enables cross-repository reasoning without the user needing to specify which files are relevant. Roo Code takes a more explicit approach: users specify files or directories the agent should reference using @file and @dir markers. This keeps context tighter but requires more upfront specification from the user.
Browser automation is more capable in Cline, which uses Computer Use for full browser control. Roo Code's browser interaction capabilities are more limited.
Roo Code added cloud features (the Cloud service and Router) that Cline does not have, targeting teams that want to share settings and run autonomous agents outside the IDE.
The community footprints also differ. As of early 2026, Cline had 58,000+ GitHub stars and 5 million+ installs, compared to Roo Code's roughly 22,000 stars and 1.2 million installs at that point (the total reached 3 million by shutdown). Cline's MCP marketplace is more established. Roo Code's mode gallery is newer but served a more specialized audience.
Roo Code can read, create, edit, and delete files across an entire project. The diff-based editing approach means changes are applied as targeted patches rather than complete rewrites, which improves both speed and token efficiency. The agent shows a diff view before applying changes, and users can approve or reject modifications at a granular level through the auto-approve settings.
The checkpoints feature creates automatic snapshots of the workspace at the start of each task and before file modifications. These snapshots use a shadow Git repository separate from any existing version control, so they work even for projects that are not in a Git repo. No GitHub account or existing Git configuration is required.
Two restoration options exist: Restore Files Only reverts the workspace files to a previous checkpoint while preserving the conversation history, and Restore Files and Task reverts both the files and the conversation, effectively undoing the entire interaction. This makes it safe to let the agent attempt risky refactors, since any unwanted change can be fully reversed.
Roo Code has full support for the Model Context Protocol, which allows the agent to interact with external services and data sources through a standardized interface. MCP servers can expose tools that the agent calls during task execution, such as database query tools, API clients, web search tools, or custom business logic.
MCP access can be granted or restricted per mode. A Documentation Writer custom mode might have no MCP access at all, while a Code mode might have access to a database tool for reading schema information and a web search tool for looking up API documentation.
When a conversation approaches the model's context window limit, Roo Code automatically uses a language model call to summarize earlier messages, compressing the conversation history while preserving essential information. This allows long-running tasks to continue without failing due to context overflow. The original messages are preserved internally, so reverting to a checkpoint restores the full conversation history.
Roo Code provides granular control over which actions require user confirmation. File reads, file edits, and terminal command execution can each be set to require approval or to proceed automatically. Commands can be filtered by allow list (only pre-approved commands run without confirmation) or by deny list (all commands except specified ones run automatically). This makes it possible to configure highly autonomous workflows for trusted operations while keeping interactive review for potentially destructive actions.
For large codebases, Roo Code includes configurable semantic indexing that allows the agent to find relevant code by meaning rather than exact string matching. This supplements the explicit @file and @dir context specification with intelligent discovery when the user does not know which files contain the relevant logic.
| Feature | Roo Code | Cline | Kilo Code | Aider | Cursor |
|---|---|---|---|---|---|
| Mode system | Yes (5 + custom) | Plan/Act only | Yes (inherited from Roo) | No | No |
| Diff-based editing | Yes | No | Yes | Yes | Partial |
| Repository indexing at startup | No (explicit context) | Yes | Yes | No | Yes |
| Browser automation | Limited | Full (Computer Use) | Yes | No | Yes |
| MCP support | Yes | Yes | Yes | Partial | No |
| Local model support | Yes (Ollama, LM Studio) | Yes | Yes | Yes | No |
| Cloud agents | Yes (deprecated) | No | Yes | No | No |
| Open source | Yes | Yes | Yes | Yes | No |
| Pricing (base) | Free | Free | Free | Free | $20/month |
| IDE support | VS Code | VS Code | VS Code | Terminal | VS Code (proprietary) |
| Stars (early 2026) | ~22,000 | ~58,000 | ~10,000 | ~24,000 | N/A |
Kilo Code is itself a fork of both Cline and Roo Code, created to build a superset of features from both projects. It raised $8 million in December 2025. It added capabilities including voice prompting, session synchronization across devices, and a deployment tool called Kilo Deploy. After Roo Code's shutdown announcement, Kilo Code explicitly positioned itself as a migration target for Roo Code users.
Aider is a terminal-based coding agent with a different interaction model. It integrates more deeply with Git, creating commits for each change rather than using a shadow repository. Aider's diff-based approach predates Roo Code's implementation.
Cursor is a proprietary VS Code fork (not an extension) with a native AI assistant. It offers a more polished editing experience for some tasks but is closed source, does not support local models, and requires a paid subscription for full functionality. Roo Code's mode system and broader model support give it an advantage for users who need more control over agent behavior or want to use models outside Cursor's supported set.
Claude Code is Anthropic's own terminal-based coding agent, released in early 2025. It is tightly integrated with Claude models and optimized for agentic workflows, but it operates in a terminal environment rather than inside VS Code and does not have a mode system comparable to Roo Code's.
The VS Code extension is free and open source. The only cost associated with the base extension comes from AI model API usage, which users pay to their chosen provider directly. Using local models through Ollama or LM Studio incurs no API costs at all.
The Roo Code Cloud service, prior to the May 2026 shutdown, offered:
| Plan | Price | Cloud features |
|---|---|---|
| Free | $0 | Token tracking, task history sync, task sharing, early access to free models |
| Pro | $20/month + $5/hour cloud tasks | Cloud agents (PR Reviewer), remote task control |
| Team | $99/month + $5/hour cloud tasks | Unlimited team members, shared settings and rules, centralized billing, GitHub and Slack integration |
All three cloud tiers also provided access to the Roo Code Router for simplified model access.
Roo Code is most effective for development tasks that benefit from structured agent behavior or that involve complex multi-file changes. Several patterns emerged as common uses across the community:
For large refactoring projects, the typical workflow is to use Architect mode to generate a step-by-step migration plan, review the plan, then switch to Code mode to implement each step with checkpoints enabled. If Code mode makes an unwanted change, the checkpoint system allows a clean rollback without losing the rest of the conversation context.
For debugging sessions, Debug mode's methodical approach works well for intermittent failures or errors with misleading messages. The mode adds targeted logging, inspects the output, narrows down hypotheses, then proposes a fix once the root cause is confirmed. This process catches more bugs than asking a general-purpose agent to fix an error description without additional context.
For onboarding to an unfamiliar codebase, Ask mode provides explanations and diagrams without any risk of accidental modification. Using @dir to point the agent at specific modules and then asking questions about how they work is a faster way to build a mental model than reading code linearly.
For large-scale feature work, Orchestrator mode coordinates multiple specialized agents. A project to add a payment integration might involve Architect mode planning the API changes, Code mode implementing the backend, Code mode writing tests, and Debug mode investigating a test failure, all coordinated by the Orchestrator with summaries passing between steps.
Custom modes serve teams that need standardized AI workflows. A team might create a Security Reviewer mode with read-only access that applies specific security review criteria, or a Migrations Writer mode restricted to SQL files with custom instructions about the company's migration conventions.
The extension attracted a strongly positive early audience, particularly among developers who found Cline too conservative in its approach or who wanted more structured control. Hacker News discussions described it as getting "rave reviews" shortly after the Cline rebrand in early 2025.
The VS Code Marketplace rating at 5 stars across 345 reviews reflected consistent user satisfaction, though reviews by their nature skew toward satisfied users. The Discord community, Reddit community (r/RooCode), and active GitHub issues page indicated an engaged user base.
More critical assessments noted a steeper learning curve compared to Cline. The mode system requires users to understand which mode to use for which task, which adds cognitive overhead compared to a single-mode tool. Some users reported instability in specific workflows, particularly around complex multi-file edits where the diff-based approach occasionally produced incorrect patches.
The token efficiency advantage was consistently confirmed by independent comparisons. The diff-based editing mechanism genuinely reduced costs on large files, which made Roo Code attractive to developers running high-volume automated workflows where API costs were a real concern.
The shutdown announcement in April 2026 generated substantial discussion. Many users expressed frustration at the abrupt timeline, given that the extension had an active user base and the Roomote pivot was unproven. Others noted the honest framing from the founding team and appreciated that alternatives were clearly recommended. Cline's public welcome of the Roo Code community was widely shared.
Kilo Code explicitly acknowledged the importance of the Roo Code community and its contributions to the open-source coding agent ecosystem following the shutdown announcement.
Several limitations were documented before the shutdown:
Context specification is manual. Unlike Cline's upfront repository indexing, Roo Code requires users to explicitly specify which files or directories are relevant using @file and @dir markers. For large projects where the relevant code is spread across many files, this can require significant upfront work before each task.
Browser automation is limited compared to Cline's Computer Use integration. Roo Code can interact with web pages in some workflows, but does not support the full range of browser automation tasks that Cline handles through Computer Use.
The custom mode system, while powerful, has a learning curve. Creating well-scoped custom modes requires understanding the tool group system, file regex patterns, and the interaction between role definitions and custom instructions. Users who just want a simple coding assistant may find the configuration options overwhelming.
Nested Git repositories can cause issues with the checkpoints feature, which relies on a shadow Git repository. Projects that contain Git submodules or nested .git directories sometimes cannot use checkpoints without disabling the feature.
The shutdown removes the commercial infrastructure that supported cloud features and the Router. While the open-source extension continues under community maintenance, the integrated cloud features that made the Pro and Team tiers valuable are gone.
Roo Code's influence on the open-source coding agent ecosystem is significant for a project that ran for roughly 18 months under its own brand. The multi-mode architecture it popularized was adopted by Kilo Code and has been discussed as a model for how coding agents can be made more controllable without sacrificing capability. The diff-based editing approach demonstrated measurable cost efficiency in production use, validating a design choice that Cline subsequently revisited.
The 3 million total installs and the community that formed around the project left a mark on the tooling landscape. Cline, Kilo Code, and other tools all cite Roo Code's community contributions when discussing their own development.
The GitHub repository remains archived at github.com/RooCodeInc/Roo-Code and continues to be maintained by a community team. The final version is v3.53.0.