14 min read · Reviewed 2026-05-11 by tinker-editor

Cline 2026 review: the open-source autonomous agent that finally grew up

Cline is the open-source VS Code extension that turns Claude Sonnet (and 30+ models) into an autonomous coding agent with per-step approval. Apache 2.0, 5M+ installs, MCP-native, .clinerules governance, Computer Use — the open-source agent leader in 2026.

The verdict

Best for: Developers who want an autonomous agent inside their existing editor with full source-code audit, model freedom, and version-controlled coding governance via .clinerules.

Worst for: Beginners who want a one-click integrated experience, teams without per-token-budget discipline, or anyone who wants inline completion baked in without configuring a second tool.

What Cline is, in one minute

Cline is an open-source VS Code extension (and now a multi-IDE one — more on that below) that turns your editor into an autonomous coding agent. You describe a task in natural language. Cline plans the work, edits files, runs terminal commands, calls MCP tools, and — with your approval at each step — drives the change to completion. The agent is human-in-the-loop by design: every meaningful action waits for an approve / reject / edit gate before it lands.

The project is licensed Apache 2.0, hosted at github.com/cline/cline, and as of this review the repo sits at 61,563 stars with the latest release on May 9, 2026. The VS Code Marketplace shows over 5 million installs. HackerNews mention volume is 2,907 in the last 30 days, second only to Cursor among the tools in this directory.

The product launched in 2024 under the name “Claude Dev” and was renamed Cline as it broadened beyond Claude-only. The current shape — Plan/Act, 30+ providers, MCP marketplace, computer-use, .clinerules governance — is the result of two years of fast iteration in public.

The position is straightforward: Cline is the open-source answer to Cursor’s Composer and Copilot’s agent mode. It does not try to replace your editor; it tries to be the best agent inside whatever editor you already have.

What changed in 2026

Cline in May 2026 is materially different from the extension that broke through in late 2024, and the changes are not cosmetic.

First, the editor surface has expanded. Cline started as a VS Code-only extension. In 2026, Cline runs natively on JetBrains, Cursor, Windsurf, Zed, and Neovim, plus a CLI preview for macOS and Linux. The team has been deliberate about this — Cline ships against ACP (Agent Client Protocol) where the host editor supports it, and as a native extension where ACP isn’t there yet. The practical result is that an AI-curious JetBrains user no longer has to switch IDEs to get Cline.

Second, Plan/Act is now the default workflow. The earlier versions had a single execution mode. The 2026 version splits the agent loop into Plan (the agent reads, thinks, and proposes a step-by-step plan you can edit before any code runs) and Act (the agent executes the approved plan with per-step gates). For long tasks, this is the difference between “the agent did six things, three of which were wrong” and “the agent showed me the six things, I corrected one, and it executed the rest cleanly.” The team’s framing is that Plan/Act gives you structured control, and in practice it does.

Third, the rules system has matured. .clinerules/ is a directory at the repo root where you put markdown files describing coding standards, architectural constraints, file-scoped instructions, and conditional rules (“only apply this when the agent is editing migrations”). The rules are version-controlled and ride with the repo. When the agent runs, it reads the relevant rules and includes them in the prompt. This is the same idea as Cursor’s .cursorrules and Copilot’s copilot-instructions.md, but Cline’s implementation has a sharper conditional model and better support for file-scoped overrides.

Fourth, MCP support is now first-class with a marketplace. The Cline MCP Marketplace is a curated catalog of MCP servers — Linear, GitHub, Postgres, Sentry, observability tools, internal documentation systems — that you install with one click. The underlying protocol supports stdio, SSE, and HTTP transports, and configuration lives in .cline/mcp.json so it’s version-controlled like everything else.

Fifth, Computer Use shipped. The agent can drive a real browser to verify its own UI changes — open the page, take a screenshot, check that the button it added actually rendered, retry if it didn’t. This closes the test-loop gap that purely text-based agents leave open. It is the same capability that Anthropic’s Claude API exposes via computer-use tools; Cline wires it through the agent loop and makes the screenshots part of the conversation context.

Sixth, the safety controls have stratified. Spend limits cap the total dollar amount Cline can spend in a session before pausing. Lazy Teammate Mode reduces the agent’s autonomy and asks more questions. YOLO Mode does the opposite — runs everything without per-step approval, useful for trusted, scoped tasks but not the default. The gradient gives developers a knob to match the agent’s autonomy to the work in front of them.

Plan/Act and the human-in-the-loop philosophy

The single feature that defines Cline’s character is the Plan/Act split.

Plan mode is a conversation, not an execution. The agent reads the relevant files (using its own retrieval and the repo context you’ve provided), thinks through what needs to happen, and writes a plan as a numbered list. You read it. You edit it. You add or remove steps. When the plan looks right, you flip to Act.

Act mode executes the approved plan one step at a time, with an approval gate at every meaningful action — file edit, terminal command, MCP tool call. The default UI shows you the proposed change, you click Approve or Reject, and the agent moves to the next step. The cost of this design is friction: a 12-step task involves 12 clicks. The benefit is that you never end up with an agent run that drifted six commits ago and you didn’t notice.

Cline’s framing is that this is the right tradeoff for autonomous work in a real codebase. Cursor’s Composer takes the opposite tradeoff — execute everything, present a single review queue at the end — and the failure mode is the agent contradicting its own earlier edits across files. Cline’s tradeoff is more conservative; the failure mode is the human getting tired of clicking Approve.

The Lazy Teammate / Default / YOLO gradient is how Cline lets you pick the right point on this curve for the work. Lazy Teammate is for high-stakes refactors where you want to read every step. Default is for routine multi-file work. YOLO is for tasks you’ve already validated in Plan mode and just want to run end-to-end on a feature branch.

In practice, most experienced Cline users live in Default with auto-approve enabled for safe operations (read-only file access, certain terminal commands, MCP tool calls that don’t write) and manual approve for anything that mutates state. Configuring this profile is one of the first things you do after install.

The 30+ provider story and BYOK economics

Cline supports Anthropic, OpenAI, Google, OpenRouter, AWS Bedrock, Google Vertex, Azure OpenAI, Mistral, DeepSeek, Together, Fireworks, Groq, LiteLLM, Ollama, LM Studio, llama.cpp, and many more — over 30 providers in the official list, plus a Cline Provider tier that bundles billing through the Cline team for users who don’t want to manage individual API accounts.

The economics are the same as Aider: you bring your own key, you pay per token. Claude Sonnet 4.5 is $3/$15 per million input/output tokens at Anthropic direct, and a typical heavy-use Cline session burns through $1–4 per hour. For someone using Cline as their primary tool four hours a day, expect $80–200/month in API spend.

The Cline Provider option, launched in mid-2025, lets you pay Cline (the company) directly with usage-based billing and no per-provider account management. The pricing carries a small margin over the direct API costs. For solo developers or small teams who want one billing relationship and don’t want to manage Anthropic + OpenAI + Google keys separately, this is the practical default.

The local-model path matters and works. Ollama-hosted Qwen 2.5 Coder, DeepSeek Coder V3, and recent Llama variants run real Cline tasks at zero per-request cost. The quality gap is real for hard tasks, but for routine work — refactors, boilerplate, doc updates — local models are good enough and the cost story is unbeatable.

.clinerules and version-controlled governance

The .clinerules/ directory is the feature most teams underuse and the one with the highest ROI on a real codebase.

The pattern is straightforward. Create .clinerules/ at the repo root. Drop markdown files in it describing your conventions — coding-standards.md, database.md, tests.md, do-not-edit.md. Use frontmatter to scope rules to specific paths (apply: src/migrations/**) or conditions (apply_when: agent is creating new files). Commit the directory like any other config.

When Cline runs, it reads the relevant rules based on the files in scope and includes them in the system prompt. The agent now knows that “we use Drizzle, not Prisma” or “all timestamps are stored in UTC” or “do not edit files under src/legacy/” without you having to repeat it in every prompt.

This is qualitatively different from a CONTRIBUTING.md or a wiki page that humans are supposed to read. Rules are part of the agent’s working context. They get applied automatically. They are version-controlled, which means a PR that changes the rules is reviewable, and a regression in the agent’s behavior usually traces to a rule change you can find with git blame.

For teams adopting Cline, the right path is: spend the first week building up .clinerules/ from your team’s existing conventions, then expect agent behavior quality to climb noticeably as the rules accumulate. This is the closest thing in the AI agent category to a real configuration-as-code experience, and it’s a real reason to pick Cline over alternatives that treat rules as a second-class concern.

MCP marketplace and Computer Use

Two more capabilities worth naming explicitly.

MCP Marketplace. Browse, search, install MCP servers from inside Cline’s UI. Linear server for issue tracking. GitHub server for PR and issue access. Postgres server for database queries. Sentry server for error context. Filesystem server for sandboxed file operations. Each install drops a config entry into .cline/mcp.json, the agent loads the server on next run, and the new tools become available in the conversation. Beyond the marketplace, any MCP server (custom or third-party) can be added by hand. Cline’s MCP support is the most comprehensive in the AI agent category at this point — Cursor’s MCP is also good, but Cline’s marketplace UX is the leader.

Computer Use. When enabled, the agent can drive a Chromium browser instance, take screenshots, click, type, and verify visual state. The use case is “I added a button to the dashboard — verify the button rendered correctly and triggers the right action.” The agent opens the page, screenshots it, includes the screenshot in its own context, and continues. The first time you see this work end-to-end on a real UI task it feels like a step change. The reality is that Computer Use is slow (seconds per action) and not always reliable (selectors break, modal dialogs surprise it), but for the tasks where it works, the loop closes in a way that’s hard to replicate manually.

Where Cline shines

Three concrete scenarios where Cline is the best tool for the job.

Long-running refactors with explicit checkpoints. “Migrate every controller from Express to Fastify, one route at a time, running the test suite after each.” This is the kind of task where Cursor’s Composer drifts and Aider’s single-task model is insufficient. Cline’s Plan mode lets you architect the migration as a 30-step plan, and Act mode executes it with manual gates between routes. The result is a clean PR per route, a stable test suite at every checkpoint, and full visibility into what the agent did at each step.

Open-source contribution with auditable AI usage. Cline’s per-step approval log is exportable. When you submit a PR with AI assistance and the project’s policy requires disclosure, the Cline transcript shows exactly which suggestions were accepted, rejected, or edited. This is the same pitch as Aider’s git-first workflow, applied inside an editor instead of in the terminal.

Building inside a regulated codebase. Spend caps + Plan/Act + .clinerules + open source + MCP for internal tools is the most defensible AI-agent setup in 2026 for regulated work. The combination is auditable end-to-end. Compare against Cursor or Copilot, where the agent loop is partly proprietary and the audit story leans on vendor logs. Cline’s open-source loop is the only fully-inspectable option in the agent category.

Where Cline falls short

It is not an editor. The most common Cline complaint is the same as Aider’s: the inline-completion experience that Cursor and Copilot give you is not part of Cline. You bring your own — Codeium, Copilot Free, Tabnine — and run it alongside. The doubled tooling cost is real, even if the unit costs of each are low.

The agent will overspend without discipline. A Cline session left on auto-approve with default spend caps will burn through $20 in 30 minutes if you ask it to do something ambitious. The defaults are conservative; the failure mode is users disabling the safety knobs because they’re slowing down work, then being surprised by the bill. The team has shipped good defaults but cannot make the user keep them on.

The first-hour onboarding is denser than Cursor’s. Plan/Act, providers, rules, MCP servers, spend caps, modes — every one is a feature, but the cumulative cognitive load on day one is higher than Cursor’s “click install, sign in, type Cmd+L.” For teams adopting Cline, expect a half-day pairing session for the first developer to get the patterns right, and a docs page that captures your team’s preferred config.

Cline vs Aider, Cursor, Continue

Cline vs Aider. Same target audience (autonomy, BYOK, open source), different surface. Cline is a VS Code (and now multi-IDE) extension with a sidebar UI. Aider is a CLI. Cline has Plan/Act, MCP, computer-use, and the rules marketplace. Aider has the cleanest git-first workflow and the smallest dependency footprint. The honest decision: VS Code or JetBrains primary user → Cline. Terminal-first user → Aider. Both → run both, they don’t conflict.

Cline vs Cursor. Same target task (autonomous multi-file work) at very different price points. Cursor’s $20-$200/month gets you a polished, integrated editor with Composer 2 (Anysphere’s own model) carrying volume. Cline’s $0/month subscription gets you the open-source agent inside whatever editor you already have, with BYOK API costs that scale with use. The cost crossover is around $40-60/month of Cline API spend — below that, Cline is cheaper; above that, Cursor’s bundled pricing is better value. Cursor wins on polish and integration; Cline wins on auditability and provider freedom.

Cline vs Continue. Continue is the older open-source VS Code AI extension, similar mission, different execution. Continue’s surface is more minimal — chat panel, slash commands, basic agent — and the community is smaller. Cline has more momentum, more frequent releases, and a more comprehensive feature set in 2026. Continue is the right choice for someone who wants the simplest possible open-source tool. Cline is the right choice for someone who wants the leading open-source agent.

Verdict: who should use Cline

Use Cline if you want an autonomous agent inside your editor with full source-code audit, want freedom on model providers, value version-controlled coding governance via .clinerules, or run in a regulated environment that needs an inspectable agent loop. The combination of Plan/Act, MCP, computer-use, and the rules system is the most complete open-source agent surface in 2026, and the multi-IDE story removes the historical “must use VS Code” friction.

Skip Cline if you want a polished AI-first editor without thinking about provider keys (Cursor or Windsurf are better), if you want one-click setup with zero ops (Copilot is better), or if your usage is light and you don’t want to manage a per-token bill (any subscription product is simpler).

The honest summary: Cline is the open-source tool that most professional developers should at least try once, even if their primary tool is commercial. The audit story alone justifies a project-level evaluation, and the cost story can justify a primary switch for teams comfortable with BYOK economics. The product is mature enough in 2026 that “open source means rough edges” is no longer a fair characterization — Cline is polished enough that the rough edges left are the ones every agent has.