Roo Code

Roo Code is an open-source VS Code extension that started as Roo-Cline, a fork of Cline, in late 2024. It's kept the core of what makes Cline good, bring-your-own-key, step-by-step transparency, MCP support, and has added features that Cline either hasn't built or has built differently: custom modes for defining specialized agent personas, a boomerang task pattern for multi-agent orchestration, and tighter configuration over what the agent can do automatically. If you like Cline but want more control over how the agent behaves across different task types, Roo Code is worth a serious look.

Forks in open source usually go one of two ways. They either wither quickly because the original project's maintainers outrun the fork's contributors, or they grow into something genuinely different enough to justify their existence. Roo Code, which started life as Roo-Cline in September 2024, has taken the second path. It's still recognizably a Cline fork, the foundation is the same, but it's developed a distinct identity around two features that Cline doesn't have: custom modes and multi-agent orchestration via the boomerang pattern.

Whether those additions are worth using Roo Code over Cline depends on how you work. If you run a single agent doing a single type of task, you probably don't need what Roo Code adds. If you're starting to think about multiple specialized agents handling different parts of a workflow, Roo Code is where that becomes practical without external orchestration tooling.

What Roo Code inherits from Cline

Before getting into what makes Roo Code different, it's worth being explicit about what it shares with Cline, because the overlap is substantial.

The core is the same: a VS Code extension that gives an AI model access to your file system, terminal, browser, and MCP-connected tools. Every action requires your approval before it executes. You see the full diff before a file write. You see the exact command before a terminal run. BYOK means your API keys, your model choice, your cost visibility.

All of Cline's capability is present: multi-file editing, plan mode, browser use, MCP client, per-session cost tracking. The approval model is the same. The configuration structure is similar. If you've used Cline, picking up Roo Code is familiar within the first session.

The divergence comes in the features Roo Code has added since the fork.

Custom modes: the feature that actually differentiates it

Custom modes are Roo Code's most significant addition. A mode is a named agent configuration that you define once and switch to on demand. Each mode has its own system prompt, its own set of allowed tools, and its own behavioral profile.

The built-in modes give you the idea. "Code" mode is the default: the agent can read and write files, run commands, and execute tasks normally. "Architect" mode focuses on high-level discussion and planning, with the agent encouraged to think about system design before touching code. "Ask" mode makes the agent purely conversational, for when you want to discuss something without the agent trying to take action. "Debug" mode focuses analytical attention on identifying and fixing problems.

You can create custom modes for your specific workflows. A "code reviewer" mode that only has read permissions and a system prompt focused on security and performance issues. A "documentation writer" mode optimized for producing clear technical writing based on existing code. A "migration planner" mode that assesses what needs to change before generating any code. A "test writer" mode that studies existing test patterns and produces new tests that match the project's style.

The value here is consistency and permission scoping. Instead of giving the agent different instructions every session, you encode the desired behavior once in a mode. The permissions are enforced structurally: a read-only mode literally can't write files, so there's no risk of the agent making changes when you asked it to review. That structural enforcement is more reliable than a system prompt that says "please don't change anything."

For teams where multiple developers are using the same agent, custom modes create shared workflow patterns. Everyone uses the "PR review" mode for pull request analysis and gets consistent behavior, rather than each person writing their own system prompt and getting inconsistent results.

The boomerang pattern for multi-agent work

The boomerang pattern is Roo Code's approach to multi-agent orchestration. The name describes the flow: a task boomerangs out from an orchestrator to specialized subagents and comes back with results.

Here's how it works in practice. You're in an "orchestrator" mode and you describe a large task: "add user authentication to this app." The orchestrator breaks the task into subtasks: design the database schema, implement the API endpoints, write the frontend login form, add the test coverage. It delegates each subtask to a specialized mode or agent instance. The subagents complete their parts and return results. The orchestrator integrates the results into a coherent whole.

This matters because a single agent context gets expensive and degraded over a long task. Reading hundreds of files, running tests, iterating on failures, the context window fills up and the agent's reasoning quality drops. Splitting work across multiple agents, each with a fresh context focused on a specific subtask, produces better results than one agent trying to hold everything at once.

The boomerang pattern also lets you use different models for different subtasks. A lightweight model for simpler subtasks, a more capable and expensive model for the complex reasoning parts. That token cost optimization adds up on large workloads.

Getting the most from boomerang requires good orchestrator system prompts that define how tasks should be decomposed and how results should be integrated. There's a learning curve to designing orchestration patterns that work reliably. But the infrastructure is there in the extension itself, without external orchestration frameworks.

Pricing and cost model

Roo Code is MIT-licensed open source. The extension costs nothing. You pay for the AI APIs you use through your own provider accounts, same as Cline.

The cost tracking display in the sidebar shows you running token usage and estimated cost per session. This is the same feature Cline has, and it's just as useful here. Knowing that your boomerang orchestration spawned six subtasks and consumed $4.20 in API calls tells you whether the approach was cost-effective compared to a single-agent session.

For multi-agent workloads, cost discipline matters more than in single-agent sessions because costs multiply. An orchestrator that spawns five subagents, each doing substantial reading, can burn through API budget quickly if you're not paying attention. Using lighter-weight models for simpler subtasks and reserving Claude Sonnet or GPT-5 for the reasoning-heavy parts is the practical approach.

Where Roo Code fits in the category

The comparison that matters most is with Cline, since that's the direct fork relationship. If you're evaluating Roo Code, you're almost certainly also evaluating Cline.

Cline has been developing longer, has more GitHub stars (over 60,000 vs Roo Code's 22,000), and has an optional Cline Cloud service for teams that want managed billing. The product polish and documentation are ahead of Roo Code's. The community is larger.

Roo Code has custom modes and the boomerang pattern, which Cline doesn't have in the same form. If those features are the ones you need, Roo Code is the better choice. If you don't need them, Cline is likely the safer choice given its maturity.

Against Aider, Roo Code is in the same open-source BYOK category but occupies VS Code rather than the terminal. Aider's git-centric workflow is cleaner for targeted patches. Roo Code's visual interface and multi-agent capability are better for larger, more complex tasks.

Against Claude Code, the comparison is VS Code versus terminal, and open-source BYOK versus Anthropic subscription. Claude Code's multi-file reasoning on the Claude Opus models is exceptional, but you're locked into Anthropic's pricing and model roster. Roo Code gives you provider flexibility and the ability to use cheaper models where they're good enough.

Getting started with Roo Code

Install the Roo Code extension from the VS Code Marketplace. In the extension settings, add your API key and select a model. Start with Claude Sonnet or a comparable provider if you want the best results on complex tasks.

Try the built-in modes before creating custom ones. Run a few sessions in "Code" mode for normal implementation work, "Architect" mode for design discussions, and "Debug" mode for troubleshooting. This gives you a feel for how mode switching works before you invest time in building custom configurations.

For your first custom mode, pick a workflow you do regularly where you have a consistent set of instructions you give the agent. If you always tell the agent "review this PR for security issues and performance problems, don't suggest style changes," that's a candidate for a dedicated mode with those instructions baked in and read-only permissions to enforce the no-editing constraint.

The boomerang pattern is worth deferring until you're comfortable with basic agent use. Start with single-agent tasks. Once you have a feel for how the agent behaves and what good task decomposition looks like, try orchestrating a modest multi-step project with two or three specialized subtasks. Build up from there.

The honest verdict

Roo Code earns its place as a distinct tool rather than just a Cline clone with superficial changes. Custom modes and the boomerang pattern are meaningful additions that serve real workflows. The extension is actively maintained and improving faster than I'd expect from a community fork.

The trade-offs against Cline are real: smaller community, less polish, thinner documentation, no hosted cloud option. If you don't have a specific need for custom modes or multi-agent orchestration, those trade-offs aren't worth making.

But if you're building agent workflows where different task types benefit from different agent configurations, or if you're ready to experiment with multi-agent coordination, Roo Code is the best open-source VS Code extension for that specific use case. It's free, it's extensible, and the architecture is designed for the kind of sophisticated workflows most coding agent tools don't think about yet.

Key features

• Custom modes to define specialized agent personas for different task types
• Multi-agent orchestration with a boomerang pattern for parallel workloads
• Bring-your-own-key support for all major AI providers
• Full VS Code extension with inline diffs and terminal access
• MCP (Model Context Protocol) client for tool integrations
• Configurable auto-approval for read, write, and command operations
• Per-task cost tracking with token usage display
• Browser use for web research and UI verification

Pros and cons

Who is Roo Code for?

• Developers who want to define different agent behaviors for different task types
• Teams building multi-agent workflows where one agent delegates to others
• Engineers who want Cline-style transparency with more granular configuration
• Open-source contributors who want to modify and extend their coding agent

Alternatives to Roo Code

If Roo Code isn't quite the right fit, the closest alternatives are cline , continue , aider , and claude-code . See our full Roo Code alternatives page for side-by-side comparisons.