CtrlK
Cline is an open-source autonomous coding agent that runs as an extension inside VS Code and several other editors. It gives developers a conversational interface through which an AI model can read files, write and edit code, execute terminal commands, operate a browser, and call external tools via the Model Context Protocol, all with explicit user approval at each step. Originally released in June 2024 under the name Claude Dev by Saoud Rizwan, the project was renamed Cline in October 2024 and has since grown to more than five million installs, making it one of the most widely adopted AI coding agents available.
Unlike closed AI IDEs such as Cursor (code editor), Cline does not replace VS Code. It runs inside the existing editor as a sidebar panel, leaving the developer's workspace intact. It also imposes no proprietary subscription on top of the underlying model cost: users connect their own API keys and pay the model provider directly, a philosophy the team calls "bring your own key" (BYOK). The project is licensed under Apache 2.0, and the source code is maintained at github.com/cline/cline.
Saoud Rizwan built the first version of the tool in June 2024, approximately ten days after Anthropic released Claude 3.5 Sonnet. Rizwan was working at an Anthropic-organized hackathon when he read the model card documentation describing Claude's agentic coding capabilities. He noticed that existing tools at the time, including GitHub Copilot and early versions of Cursor and Aider, did not attempt to leverage the model's ability to reason step-by-step across multi-file tasks with a large context window. Rizwan built a prototype from scratch that weekend and published it to the VS Code Marketplace under the name Claude Dev.
The initial release was minimal by design. Rizwan deliberately kept the system prompt general, choosing not to impose opinionated constraints on how the model should behave. This openness meant that early users discovered their own workflows organically. One pattern that emerged quickly was that developers would ask the agent to first produce a plan, review it, then execute. That informal two-phase habit later became the formal Plan and Act mode built into the product.
Clause Dev reached tens of thousands of installs within weeks of launch. The VS Code Marketplace extension identifier, saoudrizwan.claude-dev, was retained even after the product was renamed, and it remains the extension's identifier today.
On October 9, 2024, Rizwan announced version 2.0 of the extension under a new name: Cline. The name is a portmanteau of "CLI" and "editor," intended to convey that the tool operates equally at the command-line layer and the editor layer. The v2.0 release shipped several improvements: streamed responses rendered directly into the editor, a cancel button for interrupting ongoing tasks mid-step, and a rewritten tool-calling prompt based on XML formatting that reduced token usage by roughly 40 percent. The renaming reflected both a broader product vision and a desire to move beyond the association with a single AI provider.
The rename also aligned with a broader product ambition. The original Claude Dev name implied the tool only worked with Anthropic's models, but by October 2024 the team had already added support for OpenAI, Google Gemini, and other providers.
Through late 2024 and into 2025, Cline's install count grew steadily as the open-source AI coding space attracted developer attention. By mid-2025 the project had reached 2.7 million installs and approximately 48,000 GitHub stars. The team around Rizwan grew from a solo effort to around 20 employees, with plans to expand to 100 by the end of 2025.
On July 31, 2025, Cline announced $32 million in combined seed and Series A funding. The Series A was led by Emergence Capital, with Pace Capital, 1984 Ventures, Essence VC, and Cox Exponential also participating. Angel investors in the round included Jared Friedman (partner at Y Combinator), Eric Simons (CEO of Bolt.new), Logan Kilpatrick, Addy Osmani (Chrome DevRel lead at Google), and Theo Browne. The funding announcement also introduced Cline Teams, an enterprise tier offering organization management, centralized billing, usage tracking, and self-hosted deployment.
By May 2026 the extension had surpassed five million installs across the VS Code Marketplace and the Open VSX Registry, and the GitHub repository had accumulated over 61,000 stars with more than 6,400 forks. Version 3.82.0 was the current release.
Cline presents as a chat interface in a VS Code sidebar. The developer types a task in natural language, and Cline communicates with a configured AI model to break the task into steps. Each step may involve one or more tool calls: reading a file, writing or editing code, running a terminal command, or browsing a URL. Before any action that modifies the file system or executes a command, Cline presents the proposed change and waits for the user to approve or reject it.
This human-in-the-loop architecture distinguishes Cline from fully autonomous agents that commit changes without review. The agent shows file diffs before applying them and displays terminal commands before executing them, so the developer retains oversight of every consequential action.
Cline separates work into two phases. In Plan mode, the agent reads files, gathers context, and produces a written plan describing what it intends to do and why. The developer can read the plan, ask questions, refine the scope, or reject it entirely before committing to any changes. Only when the developer approves the plan does execution begin.
In Act mode, the agent works through the plan step by step, seeking approval at each tool-use step. The developer can interrupt at any point, redirect the task, or roll back via checkpoints.
The Plan and Act split grew out of observed user behavior in the Claude Dev era. Early users had discovered on their own that asking the model to plan first and execute second produced better results. Formalizing this into two labeled modes made the pattern explicit and added the ability to configure per-mode model preferences. For example, a developer might use an inexpensive reasoning model in Plan mode to draft the approach, then switch to a premium model in Act mode for the actual edits.
Cline can create new files and edit existing ones. When editing, it shows a side-by-side diff view so the developer can see exactly what changed before accepting. If the model makes an error or the developer wants to try a different approach, changes can be reverted via the checkpoint system.
Cline also monitors compiler and linter output during tasks. If an edit introduces a type error or lint violation, Cline can read the diagnostics and attempt a self-correction without requiring the developer to intervene.
Cline can run commands in the VS Code integrated terminal: install packages, run test suites, start and stop servers, or execute build scripts. Each command requires explicit user approval before running. After execution, Cline reads the output and uses it to inform subsequent steps. This allows it to detect, for example, that a test failed after a code change and respond by investigating the failure.
Cline uses Claude's Computer Use capability to operate a browser. It can launch web pages, click interface elements, fill forms, scroll, and capture screenshots and console logs. The browser integration is useful for front-end development tasks: after making a UI change, Cline can load the local dev server and visually verify that the change renders correctly, then report back what it observed.
Version 3.10, released in 2024, extended browser support to allow Cline to connect to an already-running local Chrome instance via remote debugging. This means the agent can operate within the developer's actual authenticated browser session, accessing internal dashboards or private pages that a fresh headless browser could not reach.
Cline uses Git under the hood to snapshot the workspace at each step. It maintains a shadow Git repository and creates a commit every time it modifies files, without touching the developer's own Git history. These checkpoints appear in the Cline UI as a timeline of task steps. The developer can restore files to the state at any checkpoint, restore only the task conversation, or restore both files and conversation together. This makes it safe to let Cline attempt risky refactors, because any step can be undone with a single click.
Cline operates with a context window determined by the underlying model. Claude models offer up to 200,000 tokens; Gemini models support up to two million tokens. As a long task accumulates conversation history, the context window fills. Cline tracks its own token usage and warns when the window is approaching capacity.
Developers can manage context explicitly using mention shortcuts in the chat: @file adds a specific file, @folder adds a directory tree, @url fetches a web page, and @problems injects the current VS Code diagnostics panel. This allows precision loading of only the context that matters for a task, rather than indexing the entire repository automatically.
The .clinerules file at the project root lets teams encode project-specific instructions: coding standards, naming conventions, which files are off-limits, and when to initiate a context handoff to a fresh session. When the context window fills to a configurable threshold, Cline can automatically start a new task and pass along a structured summary of where things stand.
Cline supports the Model Context Protocol, an open standard developed by Anthropic that allows AI agents to connect to external tools and data sources through a standardized interface. MCP servers act as small programs that expose capabilities to the agent: web search, database queries, API calls, image processing, or access to internal company systems.
Cline ships with a built-in MCP Marketplace, accessible from the extension's toolbar. Developers can browse available MCP servers by category, install them with a single click, and configure API keys through a guided setup flow. Once installed, MCP tools become available to the agent automatically. The cline/mcp-marketplace repository on GitHub accepts community submissions for new servers.
MCP Rules let teams group servers into functional categories and define trigger phrases that cause the agent to activate the relevant tools automatically. For example, a rule might specify that any message containing the word "scrape" should activate the web-scraping MCP server.
By default Cline asks for approval before every file change and terminal command. YOLO mode, introduced in version 3.10, removes those confirmation gates entirely. With YOLO mode enabled, Cline executes file edits and terminal commands autonomously until the task is complete, without pausing for approval. The feature is intended for rapid local prototyping where the developer is comfortable with the agent making many small changes in sequence. Cline's documentation warns that YOLO mode should only be used with appropriate version control in place.
Cline connects to more than 30 AI providers. The developer enters API keys directly in the extension settings, and Cline sends requests to the chosen provider at the provider's published pricing. There is no markup.
Providers supported include:
| Provider | Notes |
|---|---|
| Anthropic | Claude 3.5 Sonnet, Claude 3.7 Sonnet, Claude Sonnet 4 and 4.5, Opus models |
| OpenAI | GPT-4o, GPT-4.1, o3 and o4 series |
| Google Gemini | Gemini 2.0 Pro, Gemini 2.5 Pro; up to 2M token context |
| DeepSeek | V3, R1 and variants; low cost per token |
| Alibaba Qwen | Qwen3 Coder; strong open-source coding performance |
| Moonshot | Kimi K2, optimized for agentic tasks |
| xAI | Grok series |
| Mistral | Codestral and other variants |
| AWS Bedrock | Enterprise-grade model hosting |
| Azure OpenAI | Enterprise deployments |
| Cerebras | Qwen3 Coder at up to 2,600 tokens per second |
| Groq, Fireworks, Together, SambaNova | High-speed inference providers |
| Ollama, LM Studio | Fully local model execution |
| OpenRouter | Aggregates many of the above |
Cline's documentation recommends Claude Sonnet 4.5 for reliability on complex tasks, DeepSeek V3 or Qwen3 Coder for cost efficiency, and Gemini 2.5 Pro when a very large context window is needed. For speed on simpler tasks, Qwen3 Coder served through Cerebras reaches inference rates above 2,000 tokens per second.
A hybrid approach documented by Addy Osmani uses a cheaper reasoning model in Plan mode and a premium model in Act mode, which can reduce cost per session by more than 90 percent compared to running a single premium model throughout.
For developers who prefer not to manage API keys, Cline introduced its own inference provider accessible through app.cline.bot, which offers pay-as-you-go access to multiple models without requiring separate provider accounts. This provider charges at cost with no markup, consistent with the project's stated philosophy that "inference cannot be the business model."
Version 3.31, released in 2025, added voice input. Developers can speak tasks rather than type them, and Cline transcribes and processes the spoken input as a normal message.
Version 3.58 introduced native subagents. A primary Cline session can spawn additional agent instances, each with its own isolated context window, to work on subtasks in parallel. The orchestrating session monitors the subagents and assembles their outputs. This allows complex tasks to be decomposed and executed concurrently.
The .clinerules directory at the project root holds plain-text instruction files that the agent reads at the start of each session. Rules can specify which files the agent should never modify, which patterns to follow, how to structure commits, or when to trigger a context handoff. Rules are version-controlled alongside the code, making them sharable across a team.
Typing @ in the Cline chat opens a context picker. @file adds a specific file, @folder adds a directory, @url fetches a webpage and adds its content, and @problems injects the current diagnostics from the VS Code Problems panel. These shortcuts let developers precisely control what information the agent can see.
Cline displays a running token count and estimated cost for each task in the UI. This makes it straightforward to compare model costs across providers and to understand when a session is consuming more tokens than expected. Users have noted occasional discrepancies between Cline's reported cost and the actual charge from providers like OpenRouter; the project acknowledges this and has worked to improve accuracy in subsequent versions.
Cline Teams, launched in July 2025 alongside the Series A announcement, provides organization-level governance. Features include single sign-on (SSO), role-based access control (RBAC), centralized billing and usage dashboards, audit logs, and support for self-hosted or VPC deployments. The tier is aimed at large engineering organizations that need visibility and policy enforcement across many developers using Cline simultaneously. After 2025, the Teams tier is free for up to ten users; beyond that it is priced at $20 per user per month.
As of May 2026, the Cline extension has approximately 3.85 million installs recorded in the VS Code Marketplace (the figure is higher when counting installs through Open VSX Registry, JetBrains Plugins, and the CLI). The Marketplace page shows a rating of 3.5 out of 5 stars based on 286 reviews, with current version 3.82.0.
The extension's GitHub repository at github.com/cline/cline has over 61,400 stars, 6,400 forks, and 251 releases as of the same date. The codebase is approximately 560,000 lines, with TypeScript making up 98 percent of the source.
The project Discord server has over 20,000 members. The X (formerly Twitter) account has approximately 48,000 followers. The company reports that Cline is used by engineering teams at Samsung, SAP, Salesforce, Oracle, Amazon, Microsoft, and IBM, among others.
Cline itself is free. The developer pays only the API costs charged by whichever model provider they configure. At typical usage levels in 2025 and 2026:
These figures are rough estimates. Cline's agentic workflow makes multiple model calls per user request, as the agent may need to read several files, produce a plan, then execute each step separately. A single "implement this feature" request can trigger between five and fifteen API calls depending on the complexity of the task.
For teams, the Cline Teams tier provides centralized billing and a zero-markup pass-through model for API costs. Organizations supply their own provider keys and Cline routes calls through them, with cost visibility at the user and team level.
The following table compares Cline with the most frequently discussed alternatives as of mid-2026.
| Tool | Type | Pricing | Models | Browser automation | Open source | Human approval |
|---|---|---|---|---|---|---|
| Cline | VS Code extension | Free + BYOK | 30+ providers | Yes | Yes (Apache 2.0) | Per step |
| Cursor (code editor) | VS Code fork / IDE | $0-$200/mo subscription | Curated list | No | No | Configurable |
| Claude Code | Terminal CLI | Usage-based (Pro/Max plans) | Claude only | No | No | Per step |
| Aider | Terminal CLI | Free + BYOK | 100+ via litellm | No | Yes (Apache 2.0) | Configurable |
| Roo Code | VS Code extension | Free + BYOK | Same as Cline | No | Yes (Apache 2.0) | Per step |
| Kilo Code | VS Code extension | Free + BYOK | Same as Cline | No | Yes | Per step |
| Augment Code | VS Code extension + CLI | Subscription | Curated + BYOK | No | No | Per step |
| GitHub Copilot | IDE extension + CLI | $10-$39/user/mo | Curated list | No | No | Minimal |
Cline vs Cursor: Cursor is a VS Code fork that replaces the entire IDE and adds inline completions, background cloud agents, and codebase vector indexing. It tends to be faster for simple completions and more ergonomic for everyday coding because completions appear inline as the developer types. Cline's advantages are full model flexibility, transparent token-based pricing, open-source auditability, MCP extensibility, and browser automation. Developers who want the deepest control over model choice and cost often prefer Cline; developers who want seamless inline suggestions and don't mind a subscription often prefer Cursor.
Cline vs Claude Code: Claude Code is Anthropic's own terminal-based coding agent, released in 2025. Claude Code operates from the command line, can run in the background, and is deeply optimized for Anthropic's models. Cline runs inside VS Code, supports many providers, and has a richer UI with diff views and a task history panel. Claude Code is a natural choice for developers who prefer terminal workflows or need to run agents in CI pipelines; Cline is better suited for developers who want a visual IDE experience.
Cline vs Aider: Aider is a terminal CLI that predates Cline and takes a git-first approach, automatically committing each change with a conventional commit message. It has a two-model architect mode in which one model designs a change and a cheaper model writes it. Aider has no browser automation and no built-in subagents. Cline offers deeper VS Code integration, browser automation, MCP tools, and a more visual approval flow. Aider is often preferred by terminal-first developers who value its mature, battle-tested codebase and automatic git history.
Roo Code (formerly Roo-Cline) is a fork of Cline that was created to move faster on features the Cline team was not prioritizing. It introduces a system of named execution modes: Architect, Code, Debug, Ask, and user-defined Custom modes. Each mode has its own system prompt and can be configured to use a different model, allowing teams to optimize for different task types within a single extension. Roo Code uses a diff-based editing approach rather than full file rewrites, which reduces token consumption. As of early 2026, Roo Code had over 22,000 GitHub stars and more than 1.2 million installs.
Kilo Code forked from Cline's codebase in late 2025 and raised $8 million in seed funding. It adds an Orchestrator mode that decomposes complex tasks into subtasks and routes each to a specialist agent (Architect, Coder, Debugger). A Memory Bank feature persists structured context across sessions so the agent retains knowledge about the project over time. Kilo Code markets itself as a superset of both Cline and Roo Code.
Cline is used across a range of development scenarios:
Several limitations apply to Cline as of mid-2026:
API costs can be unpredictable. Because Cline makes multiple model calls per task, a complex session can consume significantly more tokens than a developer expects. Long tasks that span many files can cost several dollars in API fees when using premium models. The cost tracking UI in Cline has occasionally reported different figures than what providers actually charged.
Context window exhaustion is a real concern for very large codebases. Even with a 200,000-token context window, a task touching many large files can fill the window before the agent finishes. The .clinerules handoff mechanism mitigates this but requires upfront configuration.
Cline does not provide inline completions. Unlike Cursor, which shows predictive suggestions as the developer types, Cline is entirely chat-based. Developers who rely heavily on tab-completion suggestions while coding need a separate tool for that layer.
Browser automation has limitations. While the Computer Use integration is useful for visual testing, it is slower and less reliable than purpose-built browser testing frameworks. It works best for quick visual sanity checks rather than comprehensive automated test suites.
Fully autonomous operation via YOLO mode removes approval gates and carries risks if the agent misunderstands the task or makes cascading errors. The checkpoint system provides recovery, but only if the developer has version control set up correctly.
As a VS Code extension, Cline cannot operate outside of a supported editor without the CLI tool. The CLI reached stable release in 2026, but it lacks some UI features available in the extension.
Cline raised $32 million in combined seed and Series A funding, announced on July 31, 2025. The Series A was led by Emergence Capital, a San Francisco-based venture firm that has backed enterprise software companies. Pace Capital co-led or participated alongside, with additional participation from 1984 Ventures, Essence VC, and Cox Exponential. Individual angels in the round included Jared Friedman (Y Combinator), Eric Simons (Bolt.new), Logan Kilpatrick, Addy Osmani, and Theo Browne.
The company used the funding to launch Cline Teams and to grow the engineering and go-to-market team. Saoud Rizwan stated the company's thesis explicitly at the time of the announcement: "inference cannot be the business strategy," meaning Cline would not introduce a proprietary credit layer on top of model costs.
Cline is widely cited in developer communities as the leading open-source alternative to subscription-based AI coding tools. Its GitHub star count (over 61,000 as of 2026) places it among the most-starred coding agent repositories, alongside OpenHands and Aider.
Addy Osmani, a Google Chrome engineering lead and Cline angel investor, wrote publicly about using Cline for production engineering work, citing its model flexibility and the Plan and Act architecture as the reasons he preferred it for complex multi-file changes. He noted that its runtime awareness through browser automation and terminal integration distinguished it from tools that operate only on static code.
Critical reception has generally focused on cost management. Several Reddit and GitHub discussions document sessions where costs ran higher than expected, particularly with long tasks and premium models. The GitHub issue tracker includes a reported discrepancy between Cline's displayed cost and actual provider charges that was eventually acknowledged and addressed by the development team.
The extension's rating on the VS Code Marketplace (3.5 out of 5) is lower than some competing tools. Common complaints in one-star reviews mention high API costs, occasional regressions in the approval UI, and the fact that the free tier of the Cline Provider has limited capacity. Positive reviews emphasize the breadth of model support, the transparency of the approval workflow, and the quality of the Plan mode for thinking through complex changes.
The community has also produced two significant forks (Roo Code and Kilo Code), which some interpret as a sign of the project's influence and the appetite for variations on its core approach.