Roo Code

Open-source AI coding agent for VS Code, honestly reviewed. No marketing copy — just what you get when you actually use it.

TL;DR

• What it is: Open-source (Apache-2.0) AI coding agent that lives inside VS Code as an extension, with optional cloud execution for team workflows [5].
• Who it’s for: Developers who want a Cursor-level coding agent without the vendor lock-in — and who want to wire it to their own models, from frontier APIs to self-hosted open weights [2][5].
• Cost structure: The extension is free forever. You pay for inference, not the software. Run it on Gemini free tier and OpenRouter credits and the daily cost can be literally zero [4].
• Key strength: Genuinely model-agnostic with role-specific modes that keep AI focused and stop it from hallucinating its way across your codebase. 22,716 GitHub stars and 1M+ reported users — this is not a ghost-town repo [5].
• Key weakness: Tightly coupled to a running VS Code instance. Cloud and headless workflows require either a workaround (running code-server remotely) or a paid Roo Code Cloud subscription. The “free” pitch glosses over real inference costs at serious usage volumes [2][5].

---

What is Roo Code

Roo Code is a VS Code extension that turns your editor into an AI coding agent. You prompt it in natural language, it reads your project’s files, runs terminal commands, edits code, creates files, and applies diffs — with you approving each action or setting it to auto-approve and stepping back. The GitHub README pitches it as “Your AI-Powered Dev Team, Right in Your Editor,” which is accurate enough.

What separates it from simpler AI assistants is the mode system. Instead of one omnipotent chat box that tries to do everything, Roo splits work into focused roles: Code mode for writing and editing, Architect mode for planning without touching files, Ask mode for explanations, Debug mode for tracing failures, and Test mode for writing tests without changing production code [5]. Each mode has a constrained tool set, which matters — it keeps the context window cleaner and prevents the agent from, say, starting to refactor your auth layer when you asked it to explain a function [website].

The project is Apache-2.0 licensed, which means genuinely open. No “Fair-code” hedging, no commercial-use restrictions — you can fork it, embed it in your own product, and modify it freely [README]. As of this writing it sits at 22,716 GitHub stars with over a million reported users shipping with it [5].

There is also a Roo Code Cloud offering — autonomous background agents you trigger from GitHub, Slack, or the web — but the core extension is the product. Cloud is the upsell.

---

Why people choose it over Cursor, Cline, and Copilot

The reviews and community discussions converge on the same four reasons: model freedom, cost control, mode discipline, and open source transparency.

Versus Cursor. Cursor is the obvious comparison — polished, AI-native IDE with strong adoption. The complaint that drives people to Roo Code is lock-in: Cursor works best with Cursor’s model selection and Cursor’s billing. Roo Code works with OpenAI, Anthropic, Gemini, DeepSeek, Mistral, local models via vLLM — whatever you connect it to [2][4]. One DEV Community write-up describes running thousands of daily LLM calls at zero cost by stacking Gemini’s free tier with OpenRouter’s free models, reaching #1 on r/RooCode for three days with the setup [4]. That’s not possible with Cursor.

Versus Cline. Cline (formerly Claude Dev) is Roo Code’s nearest structural sibling — also an Apache-licensed VS Code extension, also model-agnostic, also human-in-the-loop. Roo Code forked from Cline and has since diverged significantly, especially on the mode system and custom modes. VibeCodeHub’s 2026 comparison lists Cline as the primary alternative, and the practical difference is: Roo is more structured (modes enforce discipline), Cline gives more of a single flexible surface [5].

Versus GitHub Copilot. Copilot is a different tier — it’s an inline code completion tool, not an agentic system. Once you’re using Roo Code, you’ve left the autocomplete conversation. The comparison is more “do I need autocomplete or do I need an agent that can read my whole repo, run tests, and fix what breaks.”

On self-hosted models. A Reddit thread in r/RooCode is entirely devoted to finding the best self-hosted model for Roo Code. A user with an H100 80GB GPU tested Qwen3-32B-FP8, Qwen2.5-Coder-32B, GLM-4-32B, cognitivecomputations/Qwen3-30B-A3B, and others. The conclusion after weeks of testing: Devstral-Small-2505 by Mistral is the winner for code tasks, specifically because it handles error correction reliably. The one noted limitation with Devstral: it can’t use line_diff, falling back to write_files for edits [3]. This is a real community finding that no marketing page will tell you.

On the InfoWorld review. Matthew Tyson’s hands-on review for InfoWorld [1] is the most granular first-person account. He built a music gear marketplace app with Roo Code in architect and code mode, starting from a blank project. The setup worked — the app ran. His friction points: terminal configuration on Windows (had to switch from Git Bash to PowerShell and run a permission command before Roo could execute shell commands), and the general observation that you’re still a long way from “prompt to ship” without supervision. His phrase: “We’ve been told developers will soon be obsolete — prove it.” His verdict is that Roo Code is impressive but still requires you to stay in the loop on architectural decisions [1].

---

Features

Mode system:

• Code Mode — everyday editing, file operations, implementation [README][website]
• Architect Mode — plans systems and specs without writing code; useful for breaking down a large task before letting Code mode loose [1][website]
• Ask Mode — explanations, docs, codebase questions [README]
• Debug Mode — traces failures, adds logging, proposes targeted fixes [website]
• Test Mode — writes and improves tests without touching production code [5]
• Custom Modes — define your own role with custom instructions and tool restrictions; you can build a “Think” mode that only outputs reasoning plans and never touches files [4]

Model support:

• Connects to any provider with an OpenAI-compatible API: OpenAI, Anthropic, Gemini, DeepSeek, Mistral, OpenRouter, and others [2][4]
• BYOK (bring your own key) or use Roo’s managed model router [5]
• Self-hosted open-weight models via vLLM — point it at your local endpoint and it works, provided the model supports tool use [2][3]
• Model assignment per mode: you can send Architect prompts to a reasoning model, Code prompts to a fast code model, and Debug to a different one entirely [4]

Agent capabilities:

• Reads and writes files across your entire repository
• Runs terminal commands (with your approval or auto-approved per setting)
• Proposes changes as diffs that you can review before they apply [1]
• Auto-approval settings for different action types — granular enough that you can approve file edits automatically but require confirmation for shell commands [1]
• MCP (Model Context Protocol) server support [README]
• Mode switching — Roo can request to switch modes mid-task when the work requires it [website]

Context and memory:

• Codebase indexing for project-wide context [README video]
• Checkpoint system for reverting to earlier states [README video]
• Configurable context window management [5]

Roo Code Cloud:

• Background agents accessible from GitHub, web, Slack [website]
• Specialized agent roles: Planner, Coder, Explainer, Reviewer, Fixer [website]
• PR reviews and fixes delivered directly to GitHub [website]
• Team collaboration across co-workers [website]

---

Pricing: SaaS vs self-hosted math

This section is where Roo Code’s pitch gets genuinely interesting — and where you need to read carefully.

The extension itself: Free. Apache-2.0. Download from VS Code Marketplace, configure a model, start using it. No trial, no feature gates on the local extension [5].

Inference costs (the actual expense): You pay your model provider directly. What you spend depends entirely on which models you use and how often:

• Gemini free tier (Google AI Studio): free up to generous daily limits — one developer reported running “thousands of daily LLM calls with zero spend” using Gemini as the orchestrator and planner [4]
• OpenRouter free tier: free for a subset of models; $10 of credits unlocks approximately 1,000 free calls per day on some models [4]
• Anthropic Claude API: pay per token — a heavy day of agentic coding with Claude Sonnet can run $5–20 depending on task size; Haiku is 20x cheaper
• Self-hosted via vLLM: inference cost is your GPU electricity after initial hardware investment [2][3]

Roo Code Cloud: Separate pricing, not detailed publicly in the materials reviewed. The website positions it as a team product with “try cloud for free” as the CTA, implying a free tier with paid plans above it. Exact Cloud pricing not available for this review.

Cursor comparison: Cursor Pro runs $20/month for a fixed set of premium model requests, after which you drop to slower models. Roo Code + your own Anthropic API key will cost more at high volume but give you more control and no artificial request caps. At low usage (a few hours of coding per day), Cursor Pro is often cheaper than BYOK Anthropic. At heavy automated usage, BYOK wins. The crossover depends on your token burn rate.

The genuinely free path: The DEV Community setup [4] is worth taking seriously: Gemini via Google AI Studio as orchestrator + OpenRouter’s free-tier models (DeepSeek V3, Qwen3 235B, Devstral Small) for code and debug. This runs at essentially zero cost. The trade-off is speed and quality relative to frontier models — but for prototyping and non-critical work, the reviews suggest it’s more than adequate.

---

Deployment reality check

Installing Roo Code is downloading a VS Code extension. That’s it — no server, no Docker, no database. The complexity only appears when you try to move beyond a local interactive session.

What works immediately:

• Install the VS Code extension, paste an API key, start coding. Five minutes from zero to first AI edit [1][4]
• Custom modes require a bit of JSON configuration but the Roo UI walks you through it [4]
• Profile switching (different model configs per mode) is built-in [README video]

Where it gets complicated:

Windows terminal setup. The InfoWorld review [1] flags this directly: on Windows with Git Bash as the VS Code terminal, Roo Code kept throwing errors when trying to run shell commands. The fix was switching to PowerShell and running a permission command. Not a dealbreaker, but not mentioned in the install docs, and it tripped up an experienced developer.

Self-hosted models. Connecting to a local vLLM instance works if the model supports tool use. But not all open-weight models do tool calling reliably — the Reddit thread [3] is a record of weeks of testing before landing on Devstral-Small as the reliable choice. If you’re running consumer hardware or testing smaller models, expect iteration before finding what works.

Headless/cloud use. This is the biggest limitation of the current architecture. Roo Code is fundamentally a VS Code extension — it needs a running VS Code instance. If you want to use it in CI/CD, in a pipeline, or on a remote server without a desktop, you have to run code-server (an open-source browser-based VS Code) in a Docker container, install the extension there, and expose it via API [2]. The Medium article [2] does this with Kubernetes ConfigMaps and custom settings injection — it works, but it’s a meaningful engineering effort, not a one-hour setup. The alternative is paying for Roo Code Cloud.

Context management. Several reviews note that long sessions require manual attention to the context window. Agentic coding burns tokens fast, and a large codebase can push you toward the model’s context limit mid-task. The checkpoint system helps with rollback but doesn’t prevent runaway context costs [1][5].

---

Pros and Cons

Pros

• Genuinely Apache-2.0. Fork it, embed it, build on top of it. No commercial restrictions, no usage fees from the software itself [README].
• Model-agnostic by design. Works with 10+ providers and any OpenAI-compatible endpoint, including local models [2][4]. You are not locked into one vendor’s roadmap or pricing.
• Runnable at zero infrastructure cost. Free tier stacking (Gemini + OpenRouter) is a real operational path, not just a marketing claim [4].
• Mode system enforces discipline. Architect mode doesn’t touch files. Test mode doesn’t touch production code. This is a structural constraint that reduces “the AI went off and did something I didn’t ask for” incidents [website][5].
• Custom modes are genuinely useful. A “Think” mode that only outputs a reasoning plan before Code mode starts has measurable impact on multi-step task quality [4].
• Strong community and ecosystem. 22,716 stars, active r/RooCode subreddit with real troubleshooting threads, not just launch-day hype [3][5].
• SOC2 Type 2 and open source. You can read exactly what the extension does with your code and credentials — no black-box trust required [website].

Cons

• Not actually free at serious usage. “Free open-source” means the software license. The inference costs on frontier models (Claude, GPT-4o, Gemini Pro) add up quickly with agentic coding, which burns far more tokens per task than chat. If you’re using it 4+ hours a day with Claude Sonnet, budget $50–200/month in API costs [5].
• Tightly bound to VS Code. Running it headless, in CI/CD, or in remote environments requires significant engineering work (code-server + Kubernetes + custom settings injection) that most developers won’t tackle [2].
• Self-hosted model quality is hit-or-miss. Open-weight models vary widely in tool-calling reliability. Finding a working configuration took one developer with an H100 weeks of testing [3].
• Still requires supervision. The InfoWorld review is honest about this: “LLMs still need good prompts. Think of this as an assistant that you guide” [1][4]. If you expected to go from brief to shipped without reading diffs, you’ll be disappointed.
• Cloud pricing opacity. Roo Code Cloud exists as a team product, but pricing is not publicly listed in the reviewed materials. “Try for free” without pricing details is a contact-sales situation dressed as self-serve.
• Windows terminal friction. Shell command execution on Windows requires setup that the documentation doesn’t prominently surface [1].

---

Who should use this / who shouldn’t

Use Roo Code if:

• You’re a developer or technical founder who wants Cursor-quality AI coding without Cursor’s model lock-in.
• You want to control inference costs — run cheap models for boilerplate, expensive models only where they matter.
• You’re comfortable with BYOK and have existing API accounts with Anthropic, Google, or OpenAI.
• You want to run it against your own self-hosted models because your codebase is sensitive and you don’t want it touching external APIs.
• You need custom mode definitions for specialized workflows (e.g., a mode that only writes tests, a mode that only explains — never edits).

Skip it if:

• You’re non-technical and have never configured an API key or touched a terminal. The setup is extension-simple but the model configuration layer assumes familiarity with API providers.
• You want an always-on autonomous agent running in the background without a running desktop VS Code. Until Roo Code Cloud matures or you build the code-server workaround, this doesn’t fit [2].
• You want to use it in CI/CD pipelines out of the box. The headless path is real but takes engineering work [2].
• Your team is on JetBrains IDEs. The extension is VS Code and forks only. JetBrains support, if it exists, is community-maintained.

Consider Cursor instead if:

• You want a polished, integrated experience without any configuration overhead, and you’re okay paying $20/month for a fixed request budget.
• Your team is non-technical and needs onboarding that doesn’t involve API key management.

Consider OpenHands or Devin instead if:

• You want a cloud-native agent that takes a GitHub issue and produces a pull request without needing a running local editor at all.

---

Alternatives worth considering

• Cline — the structural sibling. Also Apache-2.0, also model-agnostic, also a VS Code extension. Fewer built-in modes but a single flexible agent surface. Some developers prefer it for simpler setups where mode discipline isn’t needed [5].
• Continue — open-source, focuses on PR review agents and a local CLI, more oriented toward code review workflows than generation [5].
• Cursor — the polished commercial alternative. Less model flexibility, more seamless onboarding. The trade-off that drives most Cursor-to-Roo migrations is cost and lock-in [5].
• OpenHands — cloud-executed agent that takes tasks from natural language to pull request. The difference is cloud-native vs. IDE-native; OpenHands doesn’t need a running editor, Roo Code does [5].
• Devin — the expensive end of the spectrum ($20–500+/month depending on tier). Fully autonomous, enterprise-targeted. Roo Code is what you use when Devin’s price is the blocker [5].
• GitHub Copilot — inline autocomplete, not an agent. If you need completion suggestions rather than multi-step code generation and editing, Copilot is the comparison. If you’re evaluating Roo Code, you’ve outgrown Copilot’s model.

---

Bottom line

Roo Code is the right answer to a specific question: “I want an AI coding agent in my IDE, I want to pick my own models, and I don’t want to pay a fixed SaaS bill just to run it.” The Apache-2.0 license is real, the model-agnostic architecture is real, and the community behind it is real — 22,716 stars and an active subreddit with genuine troubleshooting threads are harder to fake than testimonials. The mode system is a genuine differentiator: structured AI behavior inside the editor beats one giant prompt box trying to be everything. The trade-offs are also real: inference costs add up at heavy usage, the headless/cloud story requires either engineering work or a subscription, and self-hosted model quality requires experimentation. For a developer who wants control — over models, over costs, over what the agent can and can’t do — Roo Code is the most credible open-source option in the VS Code ecosystem right now.

---

Sources

1. Matthew Tyson, InfoWorld — “Roo Code review: Autonomous AI-powered development in the IDE” (Aug 6, 2025). https://www.infoworld.com/article/4019646/roo-code-review-a-first-look-at-autonomous-ai-powered-development-in-the-ide.html
2. Duy Nguyen, Medium — “How to Build Your Own Remote Code Agent with RooCode (for Cloud Workflows)” (Nov 22, 2025). https://medium.com/@justinduy/how-to-build-your-own-remote-code-agent-with-roocode-for-cloud-workflows-0db9027cff51
3. r/RooCode — “What is the best self hosted model for Roo Code?” community thread. https://www.reddit.com/r/RooCode/comments/1l4ol5h/what_is_the_best_self_hosted_model_for_roo_code/
4. livecodelife, DEV Community — “Roo Code Workflow: Build a Free, Always-On LLM-Powered Dev Assistant”. https://dev.to/livecodelife/roo-code-workflow-build-a-free-always-on-llm-powered-dev-assistant-5692
5. VibeCodeHub — “Roo Code Review 2026: Open-Source AI Coding Agent for VS Code” (updated Apr 8, 2026). https://vibecodinghub.org/tools/roo-code

Primary sources:

• GitHub repository and README: https://github.com/roocodeinc/roo-code (22,716 stars, Apache-2.0 license)
• Official website: https://roocode.com
• Documentation: https://docs.roocode.com