Cline: the open source coding agent that doesn't cut costs
Summary
- Cline’s central bet is that the best coding agent should maximize capability, not margin on inference. Users bring their own Anthropic, OpenAI, Bedrock, or OpenRouter access, freeing Cline to use frontier models and full context instead of cheaper orchestration. “That’s the cost of intelligence,” and the commercial thesis is explicit: “Inference is not the business.”
- The product is expanding from a VS Code coding agent into an open-source infrastructure layer for agents. Cline can operate the terminal, editor, browser, and MCP services; planned surfaces include JetBrains, Neovim, and the CLI, while the SDK is intended to support agents beyond coding. Pash’s framing is “a fully modular system” for building agents, including integrations for Chrome or Jupyter Notebooks.
- Plan/Act is a user-derived control system for models that still need context, supervision, and course correction. Plan mode explores files and extracts unstated requirements; Act mode edits, runs commands, and can proceed under auto-approval. Most human engagement happens during planning, after which users can “kick their feet up” while retaining enough visibility to intervene.
- MCP turns the coding agent into the interface—and potentially the buyer—for an ecosystem of software tools. Cline’s marketplace has listed more than 150 MCP servers, with leading entries reaching hundreds of thousands of downloads; one workflow moves from a Sentry stack trace through a code fix, GitHub, and Cloudflare without leaving VS Code. The emerging business model is “selling tools to agents,” eventually through unified per-call payments rather than a thicket of API keys.
- Cline rejects RAG and Fast Apply as increasingly obsolete workarounds for weaker models. Saoud argues that agentic repository exploration preserves code relationships better than chopped-up retrieval, while Pash says RAG and Fast Apply were useful when models were weaker but can now add failure points. Claude Sonnet 4 reportedly brought Cline’s internal diff-edit failure rate to roughly 4%, versus the twenties or thirties when Fast Apply emerged, though RAG can still help with document-heavy knowledge bases and Fast Apply with very small models.
- The enterprise opportunity came from uncontrolled bottom-up adoption rather than a top-down sales design. A Fortune 5 company reportedly found hundreds of engineers already using Cline and called the unmanaged API keys, spend, and data destinations “a fire that we need to put out.” Enterprises are asking for governance, security, centralized routing, invoices, and ROI evidence such as hours saved—not subsidized inference.
- The discussion separates visibility and autonomy, with serious engineering remaining a hybrid workflow for now. Fully autonomous agents can be useful for scaffolding projects, writing tests, or trying ten bug fixes in parallel, but architecture and ambiguous product work still benefit from a supervised agent that can extract context from a human. The job is shifting from algorithms toward “tasteful architectural decisions,” with the implementation handed to Cline to go “down into the mines.”
- Open source has produced thousands of forks and formidable competition, but Cline treats that proliferation as feedback and validation. The team cited roughly 6,000 forks, Cline-derived products dominating OpenRouter’s top apps, and forks of forks raising tens of millions of dollars. Its response is to keep leading on the core loop, grow from 20 people toward 100 by year-end, and “let them copy.”
Deep dive
1. Cline is becoming an agent layer rather than remaining an editor feature
Saoud’s concise definition: Cline is an open-source coding agent that can control the terminal, editor, browser, and MCP services, becoming “this point of contact for you to get your entire job done.”
Pash extends the ambition beyond VS Code: JetBrains, Neovim, and CLI support are coming, while the SDK is intended to make Cline “a fully modular system” for building agents that are not limited to coding.
One concrete boundary-stretching use case was a conference deck built in Slidev: style rules, an agenda, and a Limitless voice transcript became JavaScript slides, with scripts and data analysis available inside the same workflow.
2. Plan/Act emerged from observed behavior, not abstract agent theory
Saoud claims credit for originating Plan/Act after Discord users independently began asking Cline to produce Markdown architecture plans before implementation. The product converted that organic workflow into two visible modes.
Plan mode encourages exploration: read files, fill the context, ask what pages or visual theme the user wants, and surface missing requirements. Act mode then follows that plan by editing files and running commands, optionally with auto-approval.
The important behavioral observation is that “most of the engagement happens in the plan mode.” Act mode becomes peripheral supervision: the developer watches for drift and course-corrects rather than manually driving every operation.
3. Claude 3.5 supplied the original technical opening
Saoud began Cline roughly ten days after Claude 3.5 came out, around June 2024, after reading Anthropic’s discussion of agentic coding. Unlike tools such as Copilot, Cursor, and Aider at the time, it appeared capable of repeatedly calling tools and completing work step by step.
Claude 3.5 also performed strongly when 90% of its 200K context window was occupied, retrieving granular details rather than attending mainly to the beginning and end. Cline was built around those two improvements: reliable long-context use and sequential action.
4. An extension preserves distribution while avoiding an editor-maintenance tax
A VS Code extension gets direct access to files, the operating system, and the terminal while inheriting useful interfaces such as before-and-after diffs. It also reduces organizational friction because developers can install it through an existing marketplace.
The host’s editor-fork framing invoked a potential $3 billion outcome. The response was blunt: the speaker “pity[ies] anybody that has to fork VS Code.” Microsoft’s rapid development, private synchronization process, marketplace changes, merge conflicts, and back-end behavior make maintaining a fork a substantial permanent burden.
Remaining an extension also makes Cline complementary: it can run inside VS Code, Cursor, or Windsurf. Those products must cover autocomplete, inline edits, Q&A, and the whole editor experience; Cline can focus on “what I think is the future of programming,” the agentic loop.
5. Autonomy is rising, but visibility still determines the right tool
The discussion separates visibility from autonomy. The host frames consumer builders such as Lovable and Replit as products for people who may never inspect code, while serious production teams may still need to see each command, tool call, and file edit.
Claude Code’s sparse, high-level checklist works because models have become good enough to return acceptable work without exposing every intermediate step. Yet autonomous tools remain best suited to scaffolding, tests, or launching ten agents at the same bug.
Cline’s stated advantage is the creative or ambiguous task that must “extract context from your brain.” One guest describes approving every edit for consequential work, but switching to “full YOLO mode” when the task merits auto-approval and a coffee break.
The host’s pushback—engineers all believe their own work is complex—produced a sharper dividing line. Algorithms that once seemed difficult can now follow a test or specification; limited context and an inability to see the human’s long-term vision leave architecture and taste as the higher-value work.
6. MCP collapses an entire developer workflow into one conversation
The episode’s strongest example begins with a buggy Cloudflare Worker: Cline retrieves the Sentry stack trace through MCP, fixes the code, uses GitHub to close the issue, and deploys to Cloudflare. Natural language replaces the context switching among several products.
When Anthropic introduced MCP, even models did not understand it. Much of Cline’s early system prompt therefore explained the protocol and how to build servers, letting users watch Cline construct integrations and finally “connect the dots” about tools, services, and APIs.
Cline launched its MCP marketplace around February with one-click installation from a linked GitHub README. It has since listed more than 150 servers; the most popular have hundreds of thousands of downloads across filesystems, Git, browser automation, documentation, and search.
Context7 can query an index of popular library documentation, while local servers reach places remote APIs cannot: Unity can create objects and Ableton can make songs. Pash expects “some mix of local MCP servers and remote MCP servers” to persist.
7. MCP monetization is promising, but trust remains the gating layer
The host’s Sentry example captures the platform risk: once Sentry charged for its resolution agent, the same data could be pulled through a free MCP and handed to a coding agent. Conversely, 21st.dev’s Magic MCP monetizes an API key while injecting attractive component examples—effectively “selling tools to agents.”
Pash expects API-key billing to give way to a unified payment layer through which agents pay per tool call. Cline has discussed the problem with Stripe; stablecoins and Coinbase’s x402 mechanism surfaced as possibilities, though the implementation remains unsettled.
Security is less hypothetical. An unknown maintainer can alter a previously reviewed repository, so Pash forked servers such as the Perplexity integration to pin trusted code. If Anthropic launches an official registry, Saoud expects the ecosystem to converge around it because “they just have such good distribution.”
8. Open source is simultaneously Cline’s distribution engine and its competitive pressure
The team cited roughly 6,000 forks, with VS Code search results crowded by Cline derivatives and even “forks of forks” raising large rounds. Saoud said OpenRouter’s top three apps were Cline and two Cline forks, while billions of tokens were being sent through all the forks.
The Twitter exchange with Roo Code was characterized as friendly “timeline” banter, not a serious feud. Samsung was mentioned as possibly using an isolated internal fork—exactly the kind of enterprise adoption that source availability makes possible.
Pash acknowledged the asymmetry: Cline funds benchmarking and publishes robust diff-edit work, then competitors can raise tens of millions on top of it. His answer is leadership through continued execution: “Let them copy,” while the team grows from 20 people toward 100 by year-end.
9. Better frontier models are erasing the application-layer workarounds
Saoud traces RAG’s popularity to 2022, when vector databases were marketed as giving AI “infinite memory.” For code, chunking files and retrieving isolated pieces can break logical relationships and distract the model; Cline instead explores folders, imports, and files as a senior engineer would.
He still preserves a narrow exception: RAG can work for large collections of human-readable documents where internal logic matters less. The objection is to procurement checklists demanding codebase indexing without first asking, “Well, why?”
Fast Apply addressed unreliable search-and-replace by letting a frontier model emit vague edits—sometimes “rest of the file here”—then asking a small, likely Qwen 7B-class model to reconstruct the file. That introduces two failure points, subtle deviations, and output limits of 8K, 16K, or perhaps 32K against files that can reach 42K tokens.
Cline’s internal Claude Sonnet 4 benchmark reportedly reached roughly 4% diff-edit failure, down from the twenties or thirties around July 2024. Fast Apply vendors candidly estimated their window at “maybe three months, maybe less,” though small constrained models such as DeepSeek might still justify it.
10. Refusing to subsidize inference creates the enterprise business model
Cline currently lets users connect directly to Anthropic, OpenAI, Bedrock, or OpenRouter. Open source exposes the prompts and destinations, helping developers accept spending $10, $20, or even $100 per day because they can see where the money and data go.
Pash argues that a $20-per-month plan creates pressure to retrieve snippets, offload work to weaker models, or use another model for edits. BYOK reverses the incentive: Cline benefits by building the strongest agent, even when that makes individual tasks expensive.
The “real answer” to how Cline earns money is enterprise. After publishing a contact form without a finished enterprise product, the team heard from a Fortune 5 company with hundreds of existing users and no control over API keys, spending, or data destinations: “Please just let us give you money.”
Buyers want governance, security, centralized or self-hosted routing, invoices, and evidence such as hours saved or lines written. Even that ROI is incomplete: Cline enables experiments, side projects, and neglected bug fixes that developers otherwise “would’ve never even bothered doing.”
11. CLI and SDK make background agents another modality, not the destination
The forthcoming CLI can run in cloud processes or GitHub Actions, spawn additional Cline instances, and let another interface take over an existing local session. This is the form factor for fully autonomous and parallel operation.
Saoud rejects an either/or choice among Cline, Codex, Devin, Cursor background agents, and Kanban-style multi-agent systems. Parallel agents may generate five landing-page variants; a single interactive agent may be better for a complicated plan that requires extensive human context.
The longer-range ambition is an open-source foundation portable to Chrome, JetBrains, Jupyter Notebooks, a smart car, or “your fridge.” Cline wants to provide the building blocks for whatever follows today’s background and multi-agent patterns.
12. Context needs continuity more than speculative long-term memory
Context management covers what the model loads and how it handles the context window’s full lifecycle. The proposed approach is to give the model tools and signals—such as file exploration, open tabs, and AST summaries—then let it zoom from directory-level symbols into full files. Open tabs performed particularly well internally, almost as if the agent were “reading your mind.”
Knowledge-graph tools might enable repository-wide queries such as locating and deleting every unused function. The caveat is model specialization: a clever new tool can underperform when Claude 4 has been trained around grep, forcing application developers to support distinct model families.
Near the limit, simply deleting the first half of a conversation destroys “narrative integrity”—like starting a book halfway through. Deduplicating file reads helps, but asking the model to summarize the details that still matter has worked much better.
Saoud calls most free-form coding-agent memories “mostly useless”; stable conventions belong in explicit rules or guideline files. More promising is the team’s internal to-do scratchpad, which kept an agent on course through repeated compactions and tasks lasting roughly 10× a context window by recording what was done, what remained, and which files mattered. This builds on the earlier Memory Bank concept of maintaining a scratch pad in Cline rules.