The Workshop · 12 min mission

Cline & Zoo Code: Open-Source Agent Lineage

Choose between Cline's cross-surface Plan/Act workflow and Zoo Code's role modes, permissions, and opt-in context gathering.

ide-agentsclineroo-codezoo-codemcpplan-and-actopen-sourcebyokFact-checked 2026-06-15

On this page

Plan vs Act: a mutation boundary
Customization: role modes versus reusable capabilities
MCP: connect external tools

Cline and the Roo lineage are open-source, Apache-2.0, MCP-first coding agents. You bring your own model and approve each step unless you deliberately enable auto-approve. Cline separates non-mutating Plan work from Act execution and now spans VS Code-family editors, JetBrains IDEs, and preview CLI/ACP surfaces. Roo Code forked Cline and added role-based modes, but its extension was shut down 2026-05-15; the maintained direct successor is Zoo Code. Current snapshots checked 2026-08-22: Cline v4.1.12 and Zoo Code v3.78.0.

Extension	Status	Current version	Install?
Cline	Maintained across editor, CLI, and ACP surfaces	`v4.1.12` (2026-08-21)	Yes
Roo Code	Archived / shut down 2026-05-15	`v3.54.0` (last)	No — read-only repo
Zoo Code	Maintained direct community fork of Roo Code	`v3.78.0` (2026-08-15)	Yes — Roo successor
Kilo Code	Separate Roo descendant, IDE-committed	n/a	Yes — alternative

Lineage and status. Roo/Kilo history remains bounded to the 2026-06-15 review; Cline and Zoo release snapshots were refreshed 2026-08-22.

Cline, Zoo Code, or Kilo Code — which fits you?

Which IDE agent?

Five quick questions about where you code, how much autonomy you want, how you'd rather pay, whether open source matters, and your main language — and you'll get a single agent to start with, the reasoning behind it, and a compatible runner-up when one is available. All five contenders are in the legend below.

0/5

Preferred surface· 1 of 5

Where do you want it to live?

The five contenders

Cursorclosed source

An AI-first editor with fast Tab completion, a local agent, and event-driven Cloud Agents; Origin remains an early beta for paid plans.

GitHub Copilotclosed source

Drops into the editor you already use with completions, agent mode, reusable Agent Plugins, and enterprise plugin/MCP governance.

Devin Desktop (was Windsurf)closed source

Cognition’s desktop editor, formerly Windsurf. Devin Local is primary/default; Cascade remains a documented legacy lane with no published global removal date.

Clineopen source

An open-source agent for VS Code-family and JetBrains editors, with preview CLI/ACP surfaces and rules, skills, hooks, MCP, and plugins.

Zoo Codeopen source

The maintained direct successor to archived Roo Code: an open-source VS Code agent with Custom Modes, BYO models, and opt-in DCG.

Answer a few questions about surface, autonomy, budget, and open-source needs to get a starting recommendation across the IDE-agent field, including the Cline and Roo lineage covered here.

Install Cline in VS Code

Search the Marketplace by extension ID
Open the Extensions view and search saoudrizwan.claude-dev (publisher saoudrizwan). The claude-dev id is a leftover from the project's original name "Claude Dev" — it is not an official Anthropic product.
Install and open the sidebar
Install the extension and open the Cline panel from the activity bar. The release snapshot checked for this guide is v4.1.12 (2026-08-21).
Add a model provider
In Settings, pick a provider and paste an API key (BYOK), or use Cline-managed inference at cost. See the provider table below.
Start in Plan mode
Cline opens with the Plan/Act toggle. Stay in Plan to let it read and propose before any file changes.

Surface	Current route	Status / boundary
VS Code family	VS Code, Cursor, Antigravity; manual VSIX for VSCodium and Windsurf	Primary extension surface
JetBrains	JetBrains Marketplace	Separate official plugin
CLI	macOS and Linux	Public preview
ACP clients	Zed and Neovim through Agent Client Protocol	Client integration; capabilities depend on the host

Cline installation surfaces documented as of 2026-08-22. Preview and ACP surfaces do not imply feature parity with the primary editor extensions.

Plan vs Act: a mutation boundary

Cline has two modes. Plan mode can read the codebase, search, and discuss strategy without changing the workspace. Act mode retains the planning context and can modify files and execute the agreed work. Plan mode does not write a plan file by default; it withholds mutating tools so the agent can investigate safely. For a heavier file-aware pass that explores the codebase, identifies affected files, and asks clarifying questions, use /deep-planning.

There is a version boundary worth naming. The canonical Plan/Act guide still says Plan cannot execute commands. Cline's 4.1.x staged SDK bundle release notes describe a narrower capability: read-only shell investigation is allowed, while mutating commands, redirection, Git writes, and package installs remain hard-blocked. Treat workspace mutation—not the presence of every shell invocation—as the stable safety boundary, and check which bundle your surface is running.

Plan vs Act — same agent, different tool access

Plan mode

Allowed: read files, search the codebase, and discuss strategy. The staged 4.1.x SDK bundle can also run read-only shell investigations.

Blocked: file writes and mutating shell operations.

Use it to understand the codebase without changing the workspace.

Act mode

Inherits full context from the Plan session.

Allowed: modify files, run commands, execute the agreed strategy.

Every edit/command still needs approval unless auto-approve is on. Checkpoints let you roll back any step.

Set per-mode models (opt-in cost lever)

Enable the split
In Cline Settings, turn on "Use different models for Plan and Act." Until enabled, both modes use the same model — so trivial edits silently pay reasoning-model prices.
Assign a reasoning model to Plan
Pick a strong reasoning model for Plan, where thinking is expensive but edits are cheap.
Assign a fast model to Act
Pick a faster, cheaper model for Act, where you are mostly applying decisions already made. Switching modes auto-switches the model; preferences are stored globally.

Mode	Tool groups	Purpose
💻 Code (default)	`read`, `edit`, `command`, `mcp`	General implementation — full access
❓ Ask	`read`, `mcp` only	Explanation; no edits, no commands
🏗️ Architect	`read`, `mcp`, `edit` (markdown only)	Design/planning; can write docs, not code
🪲 Debug	`read`, `edit`, `command`, `mcp`	Troubleshooting with the full toolkit
🪃 Orchestrator	Delegates via `new_task`	Splits work into subtasks routed to other modes

Roo Code / Zoo Code built-in role modes and their scoped tool-group access. Zoo Code inherits this design 1:1 as the live successor.

Method	How
Dropdown	Mode selector menu in the chat input
Slash command	`/code`, `/architect`, `/ask`, `/debug`, `/orchestrator`
Keyboard shortcut	`⌘+.` (macOS) / `Ctrl+.` (Windows/Linux)
Agent suggestion	Accept the agent's own suggested mode switch

Four ways to switch modes in Roo Code / Zoo Code.

Customization: role modes versus reusable capabilities

Custom Modes remain the signature Roo/Zoo design: define a persona (security reviewer, test writer) with custom instructions, scoped tool access, and file-pattern permissions such as editing only *.test.ts. Zoo Code has supported per-mode MCP allowlists since v3.60.0, so an Ask persona can be prevented from reaching a server that writes to production.

Cline does not copy Zoo's role-mode permission model, but "rules only" is no longer accurate. Cline supports project or global .clinerules/, on-demand Skills, lifecycle Hooks, and MCP. It also documents Plugins that package rules, skills, hooks, and MCP configuration. Plugin availability is staged: the canonical plugin guide currently scopes plugins to the SDK, CLI, and Kanban surfaces, while 4.1.x release notes describe an extension SDK/legacy-bundle rollout. Verify the active bundle before treating a plugin as portable across every Cline surface.

MCP: connect external tools

Both tools treat the Model Context Protocol (MCP) as core. Cline ships an MCP Marketplace (docs: "Use Cline's MCP Marketplace for one-click install when available") reached via the MCP Servers icon, and can scaffold a custom MCP server from a natural-language description or clone an existing server repo from GitHub as an agent task. Config is plain JSON supporting both transports: a local STDIO server uses command + args; a remote server uses url + optional headers over HTTP/SSE.

~/.cline/mcp.json — a local STDIO server and a remote HTTP server

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "./src"]
    },
    "company-api": {
      "url": "https://mcp.example.com/sse",
      "headers": { "Authorization": "Bearer ${API_TOKEN}" }
    }
  }
}

Provider	Mode
Anthropic (Claude), OpenAI, Google (Gemini)	BYOK — your own API key
AWS Bedrock, Azure, GCP Vertex	BYOK — your own cloud endpoint
DeepSeek, xAI (Grok), Mistral, Cerebras	BYOK — your own API key
OpenRouter	BYOK — `200+ models from any provider`
Ollama, LM Studio	Local weights — nothing leaves the machine

Representative bring-your-own-model routes documented by Cline. Provider and model shelves change independently of the extension version; use the live provider picker for exact availability.

Tool	Free tier	Paid option
Cline	Open Source — free; BYOK or Cline-managed inference at cost	Enterprise (custom): SSO, SLA, JetBrains extension, support
Zoo Code	`free and open source forever`; BYOK	Optional Zoo Gateway — pay-as-you-go credits, single unified API

Pricing tiers as of 2026-06-15.

Dimension	Cline	Roo Code → Zoo Code
Mode model	Plan (no workspace mutation) and Act (execute)	Five role modes + Custom Modes with scoped tools/files
Specialization	Rules, Skills, Hooks, MCP, and staged Plugins	Modes; per-mode MCP allowlists; opt-in DCG in Zoo `v3.76.0`
Editing style	Whole-file writes	Diff-based editing (community-cited token savings)
MCP	Built-in Marketplace; can scaffold/clone servers	Connect servers; per-mode server restrictions
License	Apache 2.0	Apache 2.0

Cline vs the Roo Code lineage. "Roo Code" describes the design; the installable extension carrying it forward is Zoo Code.

plan → approve → act, the Cline loop

… scroll to run this session

Plan mode reads and proposes without touching anything; you flip to Act; each edit still waits for approval.

Knowledge check

A teammate asks you to recommend "Roo Code" for their VS Code setup. What is the current guidance?

Reach the end and this star joins your charted sky.