Cline (formerly "Claude Dev", cline/cline, Apache 2.0) has over a million installs as of 2026. Unlike Copilot's line completions, it does the whole task — the same agent shape as Cursor or Windsurf, except free, open-source, and running against any model you configure. The one condition: you supply the API key.

Cline vs Cursor vs GitHub Copilot

The trade-off: Cursor and Copilot give you a managed experience and a predictable bill. Cline gives you full transparency over the model, prompts, and per-token cost — at the price of wiring up your own key, a five-minute job if you already keep API keys around.

The Features That Matter

Plan and Act modes. Cline's marquee feature is the explicit Plan/Act toggle. In Plan mode the model can only read files and write a step-by-step proposal — no edits, no commands. In Act mode it executes, asking approval before each irreversible tool use. You can even assign different models to each: a frontier reasoner (Gemini 2.5 Pro, Claude Opus, GLM 5.2) for planning, a fast cheap model (gpt-oss-120b on Groq, Gemini 2.0 Flash) for the mechanical edits.

Bring-your-own-model. The longest provider dropdown in the category: Anthropic, OpenAI, Gemini, DeepSeek, Groq, Together AI, Mistral, OpenRouter, AWS Bedrock, Vertex AI, Azure, OpenAI-compatible local servers (Ollama, LM Studio, llama.cpp, vLLM), and LiteLLM. Pick the cost/quality point per task, and adopt any new state-of-the-art model the day it lands.

Native MCP support. Cline was one of the earliest agents to ship native Model Context Protocol support. Any MCP server — filesystem, GitHub, Postgres, Playwright, Slack — plugs into its tool list, and an in-app marketplace lists hundreds of community servers you install in two clicks.

Browser automation + live cost. A built-in headless browser lets Cline open a URL, screenshot, click, type, and read the DOM — so it can make a UI change and verify it visually. Every task shows a running token counter and dollar estimate, so you can hit Stop the moment it stops being economical.

Install and Connect a Free API

Installation takes about thirty seconds: open the Extensions panel (Ctrl+Shift+X), search Cline (publisher: saoudrizwan), Install, click the Cline icon, then pick a provider and paste a key on first launch. It runs in any VS Code-compatible editor (VS Codium, Cursor, Windsurf). The extension makes no network call until you give it a model.

The provider you pick decides whether Cline is genuinely free. Four zero-cost options:

• Google Gemini (best for starters) — free tier on aistudio.google.com gives the current Gemini 3.x line at a 1M-token context. Note that 2.0 Flash and 2.5 Pro were retired, so any guide naming those model strings will fail on the first call; pick whatever 3.x flash/pro pair the console lists. Google also stopped publishing its free-tier rate limits, which are now per-account and visible only inside AI Studio.
• OpenRouter — one endpoint, dozens of providers, a :free tier. Sign up at openrouter.ai, and in the model search type :free for z-ai/glm-5.2:free or nvidia/nemotron-3-super-120b-a12b:free. Tighter limits than Gemini, unmatched variety.
• Ollama (fully local) — ollama pull qwen2.5-coder:14b, choose provider Ollama, set base URL http://localhost:11434. Below frontier quality, but good enough for boilerplate and small refactors with zero tokens leaving your machine.
• Groq (fastest) — openai/gpt-oss-120b at roughly 520 tok/s, no card, 1,000 requests a day. Choose the OpenAI-compatible provider with base URL https://api.groq.com/openai/v1. The daily ceiling that actually binds is 200,000 tokens, not the request count — an agent loop reaches it well before 1,000 calls.
• Not free any more: Together AI puts the account in read-only until you make a deposit, and Cerebras, DeepSeek, SambaNova and xAI all now require a payment method. Guides recommending them as $0 Cline backends are out of date.

Which Free Model Actually Finishes the Job

Every "fastest free API" comparison — ours included — measures tokens per second. That number tells you how fast a model talks. For an agent it tells you almost nothing, because the job is only done if the files changed.

So we put four free models inside a real agent runtime with filesystem and shell access, gave them ordinary chores, and then inspected the filesystem rather than trusting what the model claimed. The same failure modes show up in Cline, because it is the same shape of work — read files, run commands, edit, repeat.

The dangerous result is the second row. Nemotron was the fastest debugger in the test and then reported a completed job it had not started. In Cline that reads as a confident summary in the chat pane with nothing in the diff — which is exactly the case where auto-approve costs you more time than it saves.

What this means for picking a Cline backend: favour the model that was boringly consistent over the one with the best single time, keep approvals on until you have watched a model finish a multi-step task honestly, and judge any model by the diff it produces rather than by what it says it did. Full method and the jobs we used: we gave free AI models real agent jobs.

What a Real Task Looks Like

A typical session — "Add a dark mode toggle to the navbar, persist it in localStorage, use the existing Tailwind dark: variants." In Plan mode Cline reads tailwind.config.js and Navbar.tsx, searches for existing theme context, and writes a plan (add a useDarkMode hook, a toggle button, an effect syncing the dark class). You approve, flip to Act mode, and Cline creates the hook, edits the navbar, runs pnpm run dev, opens the page in its browser, screenshots before/after clicking the toggle, and reports done with files changed and cost (e.g. "$0.04, 18,200 tokens") — pausing for approval at each diff and command.

MCP: Reaching Beyond the Editor

Three servers worth installing on day one (from the Cline marketplace): filesystem (cross-repo refactors), github (open issues and PRs), and playwright (reproduce user-reported bugs). Custom servers drop into ~/.cline/mcp.json:

{
  "mcpServers": {
    "my-postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgres://localhost/dev"]
    }
  }
}

After a reload, Cline can run read-only SQL against your dev database without pasting schemas into chat.

Cost: Cline + Free API vs Cursor / Copilot

If you bill clients, $20/mo for Cursor pays for itself in the first hour. If you're a hobbyist, student, or OSS maintainer, Cline + a free tier gets ~80% of the experience at $0. They aren't exclusive — Cursor is itself a VS Code fork, so you can run Cline inside it.

Cline vs Aider vs Continue.dev

Live in VS Code and want full autonomy → Cline. Live in tmux with every change tied to a commit → Aider. Want team-shareable autocomplete plus chat → Continue.

Tips to Keep Cost Low

• Use Plan mode aggressively — a 2,000-token plan beats a 20,000-token wrong execution.
• Add a .clineignore so it skips node_modules, lock files, and build outputs.
• Pin the model per task — small fast model for find-and-replace, frontier for design and debugging.
• Cap with maxRequests (e.g. 30) to stop runaway loops.
• Pair with Ollama for repetitive work like test generation — "free" tokens.

Frequently Asked Questions

Is Cline really free?

The extension is free under Apache 2.0. The model calls are not — you pay whichever provider you connect, or nothing if you stay within a free tier or run Ollama locally. There is no Cline-the-company subscription gate.

Which free model should I point Cline at?

Pick for consistency, not speed. In our agent test the fastest debugger (Nemotron Super 120B) also reported a folder-tidying job as complete without moving a single file, while Kimi K3 finished every job it was given. Groq's openai/gpt-oss-120b is the quickest free backend to set up with no card. Whatever you choose, verify by the diff rather than the chat summary.

Will Cline silently delete my files?

No. Every file write, terminal command, and browser action requires explicit approval before it runs (the default), and Cline shows you the diff or command before you click Approve.

Can Cline read my whole codebase?

It reads files on demand via a search-and-grep flow rather than embedding the whole repo, so you need no vector database. For very large repos, pair it with a long-context model (Gemini 2.5 Pro at 1M, Claude Sonnet at 200K).

What's the difference between Cline and Roo Code?

Roo Code is a popular fork of Cline with extra "modes" (Architect, Code, Ask, Debug) and different UI conventions. Functionally similar; both are free and open source — pick the interface you prefer.

Final Verdict

Cline is the right default in 2026 for any developer who already has a free AI API key and wants a serious coding agent without a subscription. The Plan/Act split is better UX than the implicit modes elsewhere, native MCP means it grows with the ecosystem, and because the provider is your choice you match cost to task and switch the moment a better model lands. Cursor and Copilot remain excellent where a fixed bill and curated models are what you want — but Cline makes "AI coding agent" available to anyone with a laptop and a free key. Install it, point it at Gemini, and give it a small task.

Related Reads

• Free AI APIs in 2026: We Tested 10, Four Now Want a Card
• OpenRouter Free Tier Tested: 18 Free Models, One API Key
• MCP: Connect AI Agents to Any Tool or API
• Ollama: Run AI Models Locally for Free
• Google Gemini Free API Tested: 34s to First Token