What Is Cline? VS Code AI Coding Agent

Cline is a free, open-source VS Code extension that turns the editor into an autonomous coding agent: it reads your codebase, proposes edits, runs terminal commands, drives a browser, and iterates on its own work, all while you approve or reject each step. Originally released in mid-2024 as Claude Dev, it now supports more than 30 model providers and has passed 60,000 GitHub stars. This guide covers how Cline actually works, how it differs from Cursor, Windsurf, and Claude Code, and where it fits into a real developer's toolkit.

What Cline actually is

Cline sits inside a category that grew explosively across 2024 through 2026: AI tools that don't just suggest the next few tokens of code, they act. Instead of a chat window bolted onto your editor, Cline runs a loop where it reads files, proposes a plan, executes changes, watches the results (including compiler errors and test output), and adjusts before reporting back. It ships as a VS Code extension, a JetBrains plugin, a standalone CLI (installable with npm i -g cline), and a web-based Kanban board for coordinating multiple agent runs, according to the project's own GitHub repository (github.com/cline/cline).

The distinction between "autocomplete" and "agent" matters more than it sounds like it should. GitHub Copilot's original tab-complete watches your cursor and predicts the next line. A chat assistant like early ChatGPT plugins answers a question and stops. Cline instead treats a request like "add rate limiting to this API" as a project: it inspects the relevant files, drafts a plan, writes the code, runs the test suite, reads the failure output if something breaks, and tries again. That loop, not any single feature, is what makes Cline an agent rather than a smarter autocomplete box.

Cline crossed 65,000 GitHub stars and 7,000 forks by mid-2026, and its VS Code Marketplace install count moved from roughly 3 million in mid-2025 past an estimated 4 to 5 million by mid-2026 — extraordinary reach for a project with no dedicated marketing budget, built almost entirely on developer word of mouth.

Origin and the name change from Claude Dev

Cline was created by software engineer Saoud Rizwan, who released the first version in July 2024 as Claude Dev — a personal project built to give Anthropic's Claude models real tool-use inside VS Code, at a moment when most "AI in the editor" experiences were still limited to inline suggestions or single-turn chat. The original name reflected the fact that it was built specifically around Claude's tool-calling behavior.

As the project attracted contributors and Rizwan added support for OpenAI, Google Gemini, AWS Bedrock, and eventually dozens of other providers, the Claude-specific name stopped fitting the product. The project was renamed Cline in October 2024 — a name that keeps the "Claude" sound while dropping the vendor lock-in the old name implied. The rebrand mattered practically as much as symbolically: it signaled to the open-source community that this was a model-agnostic platform, not a wrapper around one company's API, which likely accelerated the wave of contributions and provider integrations that followed.

The license also shifted over the project's life. Cline is currently distributed under the Apache 2.0 license, per the project's own GitHub repository, which grants broader patent protections than the permissive MIT-style terms some earlier AI dev-tool forks used. For a tool that runs shell commands and edits files on a developer's machine, the licensing terms matter less to most users than the fact that the source is fully auditable — anyone can read exactly what Cline sends to a model provider and what commands it's capable of running, which is a meaningfully different trust model from a closed-source IDE plugin.

How Cline's agent loop actually works

Cline's core mechanic is a request-plan-act-verify cycle that repeats until a task is done or it needs a decision only a human can make. Breaking that into its real steps:

1. You describe a goal in plain English inside the Cline panel — "migrate this Express route to use the new auth middleware," for example.
2. Cline reads context. It scans the relevant files, often using its own project-summarization step so it isn't blindly dumping your entire repository into the model's context window.
3. It proposes a plan or a diff. Depending on which mode you're in (more on Plan versus Act below), it either lays out its intended approach in prose first, or jumps straight to showing you a concrete file diff.
4. You approve, edit, or reject each proposed action — file writes, terminal commands, and browser actions all pause for confirmation by default.
5. It executes and observes. After a command runs or a file is written, Cline reads the actual output — a failing test, a stack trace, a lint error — and folds that back into its next decision.
6. It loops until the stated goal is met, then reports what it did.

That loop is easiest to understand with an analogy. A tab-complete tool is like a GPS: it tells you the very next turn based on where you are right now, and it has no opinion about your destination beyond the next few hundred meters. Cline is closer to a contractor you've handed blueprints to: you describe the outcome you want, they figure out the sequence of steps, check their work as they go, and only come back to you when they hit a decision that needs your judgment, like whether to knock down a load-bearing wall. The GPS reacts; the contractor plans.

Why does Cline ask for approval at every step?

Because an agent with unsupervised shell access is a genuine security and correctness risk — a single hallucinated command (rm -rf in the wrong directory, a credential leaked into a log) can do real damage in seconds. Cline's default posture is confirm-before-act for file writes and terminal commands, with an opt-in auto-approval setting for narrowly scoped, low-risk actions like reading files or running an existing test suite. Running agent-generated code in an isolated environment is another way to limit that risk, which is the idea behind code sandboxes for AI agents.

Plan Mode and Act Mode

Cline's most distinctive UX decision is splitting every interaction into two explicit modes, a pattern documented in the project's own wiki and confirmed across independent 2026 reviews of the tool.

Plan Mode is where Cline explores and reasons before touching anything. It reads the files it thinks are relevant, asks clarifying questions if the request is ambiguous, and lays out exactly what it intends to do — which files it will edit, what approach it will take, what trade-offs exist. You can push back, redirect, or approve the plan before a single line of code changes. This is the stage where a misunderstood requirement gets caught cheaply, before it becomes five files of edits you have to unwind.

Act Mode is where Cline executes the approved plan: writing diffs, running terminal commands, and iterating against test output, with every file edit and command shown before it runs. Users can approve steps individually, or configure auto-approval thresholds for specific low-risk operation types.

There's also a third, faster-and-riskier configuration sometimes called "YOLO mode" in community discussion, where Cline transitions from Plan straight into Act without waiting for explicit sign-off at each step. It exists for trusted, well-scoped tasks — a documented internal script, a repetitive mechanical refactor — where the friction of step-by-step confirmation outweighs the risk. Most experienced users keep it off for anything touching production code or infrastructure.

What's the difference between Plan Mode and just asking a chatbot a question?

A chatbot's plan is prose you have to translate into action yourself. Plan Mode in Cline is a preview of the exact actions the agent is about to take — which files, which commands — that you can accept, edit, or reject before execution starts, closing the gap between "the AI described an approach" and "the AI is about to do something to my codebase."

Checkpoints: the undo button that makes agentic coding survivable

Every meaningful change Act Mode makes is preceded by a checkpoint — a snapshot of the working state you can roll back to instantly, without needing to understand or manually reverse the specific edits Cline made. This is arguably as important to Cline's usability as Plan/Act mode itself, because agentic tools are non-deterministic: the same prompt run twice can produce two different implementations, and even a well-planned change can turn out worse in practice than it looked on paper.

Checkpoints turn "the agent went down a bad path three steps ago" from a manual git-archaeology problem into a one-click rollback. Practically, this means developers can let Cline attempt a more ambitious, exploratory change than they'd otherwise risk, because the cost of "that didn't work" is a rollback rather than an hour of cleanup.

Model Context Protocol support

Cline is an MCP client, meaning it can connect to any Model Context Protocol server — Anthropic's open standard for giving AI models a common interface to external tools and data sources, from databases to internal APIs to design software. Cline was among the earliest third-party editor tools to adopt MCP after Anthropic published the standard, and by 2026 the feature had matured into one of the extension's main extensibility mechanisms.

Practically, this means a developer can wire Cline into a company's internal ticketing system, a Postgres database, a Figma file, or a custom internal API without modifying Cline itself. Install the relevant MCP server, point Cline at it, and its tools become part of what Cline can call during Act Mode. This is the same architecture that powers MCP integration in Claude Code and other 2026-era agentic tools — one protocol, many clients, growing ecosystem of servers.

The browser tool

Cline can also spin up a headless Chromium instance, navigate a running web app, click through a UI, take screenshots, and read console errors — all as part of its normal Act Mode toolkit. This closes a loop that pure code-editing agents can't: a bug that only shows up visually, or a layout issue you'd normally have to describe in words for the agent to "picture," can instead be something Cline actually looks at.

For front-end debugging specifically, this is a meaningful capability gap versus tools limited to reading and writing source files. An agent that can only read code has to infer what's broken from the DOM and CSS; an agent that can screenshot the rendered page and reason about what it sees is working from the same evidence a human developer would use.

Bring Your Own Key: the architectural decision that defines Cline

This is the single biggest structural difference between Cline and most of its commercial competitors. Cursor and Windsurf charge a flat monthly subscription — commonly around $20 per month for Cursor's Pro tier — and route your prompts through their own model proxy layer. That's convenient, but it comes with three trade-offs: you pay a markup baked into the subscription price, your code passes through the vendor's infrastructure regardless of which underlying model you're using, and you're limited to whichever models the vendor has chosen to expose.

Cline charges nothing for the extension itself and connects directly to the model provider using your own API key. You pay metered usage straight to Anthropic, OpenAI, Google, or whichever provider you've configured — no markup, no subscription tier gating features behind a paywall. For light or occasional users, this is often dramatically cheaper than a flat-rate subscription. For a developer running Cline all day on a large codebase with a top-tier reasoning model, metered API costs can exceed what a flat subscription would have charged, because there's no usage cap smoothing out the cost curve. The trade-off is control versus predictability: Cline hands you the wheel and the fuel bill both; a subscription tool hands you neither, but you always know what the ride costs.

Supported models and providers

By 2026, Cline's provider list had grown past 30, according to the project's own documentation and independent 2026 reviews, spanning both frontier labs and infrastructure providers: Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure OpenAI, OpenRouter, Cerebras, DeepSeek, Moonshot, Alibaba Qwen, xAI Grok, Mistral, Groq, Fireworks, Together, Baseten, SambaNova, Nebius, Hugging Face, and local models through Ollama or LM Studio.

That breadth matters for two different kinds of users. Developers optimizing for raw capability tend to point Cline at a top-tier reasoning model — Claude's Sonnet or Opus tier, or a comparable frontier OpenAI or Gemini model — for anything involving multi-file reasoning or subtle bugs. Developers optimizing for cost or privacy can instead route through a cheaper hosted model via OpenRouter, or skip the network entirely and run a local model through Ollama, trading some capability for zero marginal cost and code that never leaves the machine.

Table: Core Cline features and the problem each one solves

Feature	What it does	Problem it solves
Plan Mode	Explores and proposes an approach before any file is touched	Catches misunderstood requirements before they become multi-file edits to undo
Act Mode	Executes the approved plan: edits files, runs commands, reads results	Turns an approved plan into real, working code without manual step-by-step babysitting
Checkpoints	Snapshots the working state before every meaningful change	Makes a bad agent decision a one-click rollback instead of manual cleanup
MCP client support	Connects to any Model Context Protocol server	Extends Cline's tools to databases, internal APIs, and other systems without modifying the extension
Browser tool	Runs headless Chromium: click, screenshot, read console errors	Lets the agent debug visual and runtime issues it can't infer from source code alone
Terminal access	Runs shell commands with approval, streams output back	Lets Cline install packages, run tests, and use the same tools a human developer would
Bring Your Own Key	Connects directly to 30+ model providers with your own credentials	Removes subscription markup and vendor lock-in to a single model family
.clinerules files	Project-specific standing instructions Cline reads automatically	Encodes team conventions so the agent doesn't need re-briefing every session

Cline versus the rest of the 2026 agentic coding field

Table: How Cline compares to other major AI coding tools

Tool	Surface	Pricing model	Best for
Cline	VS Code / JetBrains extension, CLI, open source	Free extension + your own API key	Developers who want full control, model choice, and code transparency
Cursor	Forked VS Code IDE	Flat monthly subscription (roughly $20/mo Pro tier)	Polished, managed, fast inline-editing experience
Windsurf	Forked VS Code IDE (formerly Codeium)	Flat monthly subscription	Visible multi-step "Flows" and agent-native IDE design
Claude Code	Terminal-first, with IDE plug-ins	Bundled with Claude.ai Pro/Max, or metered API	Long-horizon agentic loops and large-codebase refactors, terminal-native
GitHub Copilot	IDE extension, deeply GitHub-integrated	Subscription (individual and enterprise tiers)	Teams already standardized on GitHub's ecosystem and Workspace/Agents features
Roo Code	VS Code extension, Cline fork, open source	Free extension + your own API key	Experimental features ahead of upstream Cline's release cycle

Claude Code is Cline's closest philosophical cousin: both run genuine agent loops with plan-act-verify cycles and both support MCP, but Claude Code is terminal-first and bundled into an Anthropic subscription, while Cline lives inside VS Code's familiar UI and stays fully model-agnostic. If you already think in terms of terminal workflows and want Anthropic's specific subagent and skills infrastructure, Claude Code is the better fit. If you want the agentic loop without leaving VS Code, and you want to choose your own model provider on a task-by-task basis, Cline is built for exactly that use case. Terminal-first developers may also want to look at Aider, a terminal AI coding tool.

How does Cline compare to Cursor specifically?

Cursor is a full IDE fork with its own polished UI, a flat-rate subscription, and an Agent mode layered on top of very fast inline autocomplete. Cline is a lightweight extension for vanilla VS Code, free itself, that connects directly to whichever model provider you choose and charges only the underlying API cost. Cursor generally wins on moment-to-moment editing polish; Cline wins on transparency, model flexibility, and total cost for lighter or intermittent usage.

The Roo Code fork

In late 2024, a community fork of the project — originally called Roo Cline, later shortened to Roo Code — split off to iterate faster on experimental features: custom operating modes, broader MCP tooling, and multi-agent orchestration patterns that hadn't yet stabilized in upstream Cline. Both projects remain open source and share the same architectural lineage, and it's common for developers to run both side by side, treating Roo Code as the testbed for features that later show up (or don't) in Cline proper. The fork is itself a useful signal about the health of Cline's ecosystem: a project healthy enough to sustain an actively maintained community fork, rather than one that quietly withers after the fork appears, tends to indicate real ongoing developer investment on both sides.

Real workflows where Cline is genuinely useful

• Bug hunts across unfamiliar codebases. Point Cline at a repository you didn't write, describe the symptom, and let it crawl the code, form hypotheses, and run tests to confirm or rule them out — faster than manually tracing call paths through code you've never seen.
• Mechanical migrations. Framework upgrades (Express to Fastify, class components to hooks, a deprecated API to its replacement) involve many small, repetitive, correctness-sensitive edits — exactly the kind of task where checkpoints make an aggressive agent attempt low-risk.
• Writing tests for legacy code. Cline can read untested code, draft a test suite against its actual behavior, run it, and fix failures iteratively, which is meaningfully faster than a human writing test scaffolding from scratch.
• UI and front-end debugging. The browser tool lets Cline take a screenshot, compare it against the described intent, and reason about DOM state directly rather than working purely from source.
• Documentation and onboarding materials. Reading a real codebase and generating an accurate README or runbook from what the code actually does, rather than from stale hand-written notes.
• Scoped API integrations. With an MCP server pointed at an internal system, Cline can wire up new integrations without a developer manually reading unfamiliar API documentation end to end.

Where Cline is the wrong tool

• You want a single-vendor, fully managed experience with zero key management. Cursor or Windsurf remove that setup step entirely, for a flat monthly fee.
• You need enterprise SSO, centralized audit logs, and admin-managed seats out of the box. That's a first-class feature in Cursor, Windsurf, and GitHub Copilot's business tiers; Cline is a single-user tool by design and doesn't ship built-in organizational controls.
• You're new to programming and don't want to think about API costs or rate limits. A flat-rate subscription tool removes a variable a beginner doesn't yet have context to reason about.
• You need real-time multi-user collaboration inside the same editing session. Cline, like most agentic coding tools in 2026, is architected around a single developer driving a single session.
• Your organization has a policy against sending code to arbitrary third-party model APIs. BYOK still means your code reaches whichever provider you configure; teams under strict data-residency or vendor-approval rules need that provider relationship vetted the same way they'd vet any other API dependency.

Common misconceptions about Cline

"Cline writes production-ready code with no review." It doesn't, and the project's own default behavior argues against that reading: every file write and terminal command pauses for approval unless you deliberately loosen that setting. Treat Cline's output the way you'd treat a pull request from a fast but occasionally overconfident contributor — read the diff.

"Free means it's cheaper than Cursor no matter what." The extension is free, but you're paying the model provider directly and without a usage cap. A developer running Cline against a top-tier model for hours a day, on a large repository, can end up paying more in metered API costs than a flat $20-per-month subscription would have charged. Whether Cline is cheaper depends entirely on your usage pattern, not on the word "free" in its pricing.

"Cline and Claude Code are basically the same tool." They share an agent-loop philosophy and MCP support, but Claude Code is Anthropic's terminal-first product bundled into a Claude.ai subscription, while Cline is a community-built, model-agnostic VS Code extension. A team standardized on Anthropic's ecosystem and terminal workflows will likely prefer Claude Code; a team that wants to shop across 30-plus model providers from inside VS Code will likely prefer Cline.

"Since it's open source, it must be less capable than commercial tools." Cline's underlying capability is a function of whichever model it's connected to, not the extension itself — pointed at the same frontier model a commercial tool uses, Cline's Plan/Act loop and checkpoint system are functionally comparable to, and in some workflows more transparent than, closed-source alternatives.

The bigger trend Cline is part of

Across 2024 through 2026, AI coding tools moved from autocomplete to agent as a category-defining shift, not a single product's feature. A few years ago, GitHub Copilot's tab-complete felt like a genuine leap. By 2026, watching an agent plan a multi-file refactor, run the test suite, read a failure, and fix it without being re-prompted at every step made pure autocomplete feel like a much smaller idea by comparison. Cline's specific contribution to that shift isn't the agent loop itself — several tools independently converged on similar plan-act-verify architectures — it's the open-source, bring-your-own-key version of it: no vendor lock-in, no closed-source trust requirement, and a provider list broad enough that developers can choose based on cost, capability, or data-handling policy rather than being stuck with whatever a single company decided to ship.

FAQ

Q: Is Cline really free? A: The extension itself is free and open source under the Apache 2.0 license. You pay only the underlying model provider — Anthropic, OpenAI, Google, or whichever you configure — at their direct metered API rate, with no markup or subscription fee from the Cline project itself.

Q: Who created Cline, and when? A: Software engineer Saoud Rizwan released the first version in July 2024 under the name Claude Dev. It was renamed Cline in October 2024 as the project expanded beyond Claude-only support to more than 30 model providers.

Q: Which model should I use with Cline? A: For serious multi-file coding work, a frontier reasoning model — a top-tier Claude Sonnet or Opus model, or a comparable OpenAI or Gemini release — tends to give the most reliable tool-use and planning behavior. Local models through Ollama trade some capability for privacy and zero marginal cost, and are more suitable for smaller, well-scoped tasks.

Q: Cline vs Cursor — which is better? A: They're different products solving overlapping problems. Cursor is a polished, managed IDE fork with a flat monthly subscription and very fast inline editing. Cline is a free extension for vanilla VS Code that connects directly to your chosen model provider. Many developers run both: Cursor for everyday inline editing, Cline for tasks where transparency, model choice, or cost control matter more.

Q: Is it safe to let Cline run terminal commands on my machine? A: By default, Cline asks for explicit confirmation before every file edit and terminal command. You can enable auto-approval for narrowly scoped, low-risk operation types, but most experienced users keep manual approval on for anything that touches a shell, since a single bad command can cause real damage.

Q: What's the difference between Cline and Claude Code? A: Claude Code is Anthropic's own terminal-first agentic coding tool, bundled into a Claude.ai subscription and built around Anthropic-specific infrastructure like subagents and skills. Cline is a community-built, model-agnostic VS Code extension that works with more than 30 providers. Both run genuine plan-act-verify agent loops and both support MCP, but they live in different interfaces and target different workflows.

Q: Does Cline support the Model Context Protocol (MCP)? A: Yes. Cline was one of the earliest third-party tools to implement MCP support after Anthropic published the open standard, and it functions as a full MCP client — any MCP server you install becomes a tool Cline can call during Act Mode.

Q: What are checkpoints, and why do they matter? A: A checkpoint is an automatic snapshot of your working state taken before every meaningful change Cline makes in Act Mode. If an agentic edit turns out badly, you roll back to the checkpoint instantly instead of manually reconstructing what changed — this is what makes it practical to let Cline attempt more ambitious changes than you'd otherwise risk.

Q: What is Roo Code, and how is it different from Cline? A: Roo Code is a community fork of Cline (originally called Roo Cline) that ships experimental features — custom modes, expanded MCP support, multi-agent orchestration — ahead of upstream Cline's release cycle. Both are open source and share the same core architecture; some developers run both, using Roo Code as an early look at features that may later land in Cline.

Q: Can Cline use local models instead of a cloud API? A: Yes, through Ollama or LM Studio, both of which are on Cline's supported-provider list. Local models avoid sending code to a third-party API and cost nothing per token, at the trade-off of generally weaker planning and tool-use reliability compared to top frontier cloud models, particularly on complex, multi-file tasks.

Q: Does Cline work outside VS Code? A: Yes. Beyond the original VS Code extension, the project also ships a JetBrains IDE plugin, a standalone CLI installable via npm i -g cline, and a web-based Kanban board for coordinating multiple agent runs, according to the project's GitHub documentation.

The takeaway

Cline's real innovation isn't the agent loop by itself — plan, act, verify, repeat is a pattern several 2026-era coding tools converged on independently. It's that Cline built that loop as a free, open-source, model-agnostic layer over vanilla VS Code, with bring-your-own-key pricing that removes both the subscription markup and the vendor lock-in that define its commercial competitors. That trade-off cuts both ways: you get transparency, provider choice, and often lower cost, but you also take on the setup and cost-monitoring work a managed subscription would otherwise handle for you. For developers who want to see exactly what an AI agent sends to a model and exactly what it's about to do to their codebase before it does it, Cline is currently the clearest expression of that philosophy in the editor.

---

Read next:

• What Is Claude Code? Anthropic's AI Coding Tool
• What Is MCP? Model Context Protocol Explained
• AI Subagents Explained — Parallel AI Work

Sources

• Cline GitHub repository, Apache 2.0 license, github.com/cline/cline
• Cline project wiki, Plan and Act mode documentation, github.com/cline/cline/wiki
• Roo Code project, github.com/RooCodeInc/Roo-Code
• Model Context Protocol specification, Anthropic (2024)
• VS Code Marketplace and independent 2026 install/star-count reporting (mid-2026 snapshots)