After Roo Code shut down in May, the “best free open-source AI coding agent” search took off again — and three names keep surfacing: Kilo Code, OpenCode, and Cline. All three are open source. All three cost $0 for the tool itself; you pay only for model tokens, or nothing at all if you point them at a local model. None of them locks you into one provider.

So the choice isn’t about money. It’s about where you want the agent to live — your editor or your terminal — and which one has the least friction for the thing you actually do all day.

TL;DR: All three are free and bring-your-own-key. Cline is the safest in-editor pick (battle-tested, MCP ecosystem, step-by-step approval). OpenCode is the terminal power-user’s agent (180K stars, 75+ providers, cleanest local path). Kilo Code is the VS Code agent for people who want automatic model routing across 500+ models without leaving the sidebar.

	Kilo Code	OpenCode	Cline
Surface	VS Code + JetBrains + CLI	Terminal (TUI) + desktop beta	VS Code + JetBrains + Cursor/Windsurf + CLI
License	MIT	MIT	Apache 2.0
GitHub stars (Jun 2026)	~25K	~180K	~64K
Base cost	$0 (BYOK)	$0 (BYOK)	$0 (BYOK)
Models / providers	500+ via Kilo Gateway	75+ providers	Anthropic, OpenAI, Google, OpenRouter 200+, local
Local LLM (Ollama/LM Studio)	Yes, OpenAI-compatible	Yes, native ollama launch	Yes, first-class
Standout feature	Auto Model routing + Orchestrator	Daily releases, terminal-native	Plan/Act + MCP marketplace
The catch	Routing quality depends on task detection	Fewer local how-tos than Cline	No auto model selection

Honest take: For most developers who live in VS Code, install Cline — it’s the most stable, has the deepest tutorial ecosystem, and its step-by-step approval keeps you in control. Reach for OpenCode if you work in the terminal or want the cleanest local-Ollama setup. Pick Kilo Code if you want intelligent per-task model routing inside your editor and don’t mind a younger codebase.

The architectural split that decides everything

These three tools answer the same job — read your code, edit files, run commands — from three different seats.

Cline lives in your editor sidebar. It runs as a VS Code extension, a JetBrains plugin, and inside Cursor and Windsurf, plus a CLI. The defining trait is its approval loop: every file edit and terminal command surfaces for your sign-off before it runs, via Plan mode (explore and strategize) and Act mode (execute). That makes it the natural fit for teams that need an audit trail. The Cline review covers the approval cadence in detail.

OpenCode lives in your terminal. It’s a TUI agent (a desktop app is in beta) with two built-in agents: a build agent with full access and a read-only plan agent. It has no sidebar — you drive it from the command line, which is exactly what terminal-first developers want and exactly what GUI-first developers will bounce off. The OpenCode review goes deeper on the TUI workflow.

Kilo Code also lives in VS Code (and JetBrains, and a CLI), so on the surface it looks like a Cline competitor. The difference is what happens under the hood: Kilo routes each subtask to a different model automatically, and its Orchestrator mode can break a big task into pieces handled by separate sub-agents.

That seat — editor vs terminal — cascades into everything else: how you invoke the agent, how local models plug in, and who each one is actually for.

Lineage: they’re more related than they look

This matters because it explains why the feature sets overlap so heavily. The family tree:

• Cline (originally “Claude Dev”) is the upstream project, started mid-2024.
• Roo Code forked Cline, then went its own way before shutting down in May 2026.
• Kilo Code forked Roo Code in 2025 — explicitly to merge the best of Cline and Roo Code into one polished extension. It was co-founded by GitLab co-founder Sid Sijbrandij and raised $8M in seed funding.
• The newer Kilo CLI is a separate fork of OpenCode. (Yes — Kilo’s editor side descends from Cline, and its terminal side descends from OpenCode.)

So if Cline’s Plan/Act and Kilo’s modes feel similar, that’s because they share DNA. The differentiation is in what each team built after the fork.

Local LLM: the path that actually matters

For a lot of readers the real question is “which one runs a local model with the least pain?” All three support Ollama, LM Studio, and any OpenAI-compatible endpoint. The difference is how much typing — and how many community guides — stand between you and a working setup.

OpenCode has the cleanest path. Ollama ships a launcher that wires an inline config for you:

$ ollama launch opencode
# starts OpenCode pre-configured with the selected Ollama model

If you’d rather configure it by hand, point a provider at the local server’s OpenAI-compatible endpoint:

// opencode.jsonc
{
  "provider": {
    "ollama": {
      "options": { "baseURL": "http://localhost:11434/v1" }
    }
  }
}

The /v1 suffix is not optional — drop it and OpenCode won’t speak the OpenAI-compatible protocol Ollama exposes. Our OpenCode + Ollama guide walks through the full setup and the file-write bug to watch for.

Cline has the most community how-tos and a first-class local picker. In the settings panel you select Ollama or LM Studio, enter the base URL, and pick a model — no JSON editing required. The catch is the context window: Ollama defaults to a small num_ctx, and a coding agent that silently truncates your project context produces confident garbage. Our Cline + LM Studio setup covers the 32K-context trap, and the privacy-first Cline build covers the fully-offline workflow.

Kilo Code supports local models through the same BYOK mechanism — add an OpenAI-compatible provider pointed at http://localhost:11434/v1 and select it. Its twist is Auto Model routing: in principle you can route cheap planning to a local model and expensive coding to a cloud one, balancing cost against capability. In practice that only helps if its task-type detection is accurate (more on that below).

Whichever you pick, the hardware floor is the same. A 7B–14B coding model at Q4 needs roughly 8–16GB of VRAM to be useful; jumping to 32B-class models for genuinely agentic work wants 24GB+. See the runaihome.com local-LLM hardware guide for the VRAM-by-model breakdown before you buy a GPU.

Kilo Code’s Auto Model routing — the headline feature

This is what Kilo bets its differentiation on. Auto Model is a routing system that picks the underlying model per request based on the task type — planning, coding, debugging, explanation — and a configured budget tier. The pitch is real: a planning step doesn’t need a $50/M-token frontier model, and routing it to something cheaper saves money without hurting the result.

The honest caveat: routing quality is only as good as the task-type detection. When it misfires — sending a gnarly multi-file refactor to a fast-but-shallow model because it read the prompt as “simple” — you get a worse result and have to re-run on a stronger model anyway, which costs more than if you’d just picked the model yourself. It’s a genuine convenience when it works, and a silent tax when it doesn’t. Kilo’s Orchestrator mode (breaking a task across sub-agents) compounds both the upside and the risk.

Kilo connects to 500+ models through its Kilo Gateway at provider pricing with zero markup, and BYOK works through any OpenAI-compatible endpoint, so you’re never locked into the gateway.

Pricing: free tools, paid tokens

The tools are free. Here’s where money actually enters.

Path	Kilo Code	OpenCode	Cline
Tool license	$0 (MIT)	$0 (MIT)	$0 (Apache 2.0)
BYOK (your API key)	Provider rates, zero markup	Provider rates	Provider rates
Local Ollama	$0 (your electricity)	$0	$0
Optional subscription	Kilo Pass $19 / $49 / $199	—	—
Team plan	$15 / user / mo	—	—

Only Kilo sells a first-party subscription. Kilo Pass comes in three monthly tiers — Starter at $19/mo (up to $26.60/mo in credits), Pro at $49/mo (up to $68.60/mo), and Expert at $199/mo (up to $278.60/mo) — with a 50% welcome bonus in the first month and a 50% bonus on annual plans. It’s optional convenience credit, not a gate: you can ignore Kilo Pass entirely and BYOK.

For OpenCode and Cline there’s no subscription to consider — your only bill is whatever your model provider charges, or $0 on local hardware. If you’re a heavy agentic user, run the math against flat-rate alternatives like Cursor Pro ($20) or Claude Code ($20); see our 7-way agent comparison for where each lands.

Benchmarks: read the harness, not just the number

A real limitation worth stating plainly: the public benchmark picture is incomplete for these three. On the official Terminal-Bench 2.1 leaderboard (tbench.ai), OpenCode paired with GPT-5.5 scores 83.4% on the native harness. Cline and Kilo Code are not on the official leaderboard as of June 2026 — so any “X is faster than Y” claim about them is unsubstantiated.

Two things follow. First, don’t treat the absence of a score as a failing grade; it just means nobody has run the standardized harness. Second, the agent harness moves the number as much as the model does — the same model can swing several points between a tool’s native harness and a uniform third-party one. We broke this down in the Terminal-Bench 2.1 leaderboard analysis. The practical read: pick on workflow fit, not on a leaderboard delta that may be measuring the harness instead of the agent.

A real gotcha I hit: the local-model context silently truncated

Wiring Cline to a local qwen2.5-coder via Ollama, the agent kept “forgetting” files I’d just shown it — it would edit one function and lose track of the rest of the module. The cause wasn’t the model; it was Ollama’s default context window. Cline sends the project context, but Ollama silently clipped it to the default num_ctx and the agent never saw the tail.

The fix is to raise the context window in a Modelfile and reload:

$ ollama show qwen2.5-coder --modelfile > qwen-coder.Modelfile
# edit the file, add: PARAMETER num_ctx 32768
$ ollama create qwen2.5-coder-32k -f qwen-coder.Modelfile
$ ollama run qwen2.5-coder-32k
# now Cline's full project context survives the round-trip

The same trap applies to all three agents on a local backend — the agent is honest about what it sent, but the inference server decides what it keeps. If a local setup feels suddenly “dumb,” check num_ctx before you blame the model.

Who should run which

Run Cline if you live in VS Code, want the most stable option with the deepest community and tutorial coverage, need MCP tool integrations (databases, APIs, infra), or work somewhere that wants step-by-step approval and an audit trail. It’s the lowest-regret default.

Run OpenCode if you’re a terminal-first developer, want the widest provider list and the cleanest local-Ollama path, or value a project that ships updates daily. The 180K-star community is the largest of the three for a reason.

Run Kilo Code if you want an in-editor agent with automatic per-task model routing across 500+ models, like the idea of Orchestrator splitting big tasks across sub-agents, and are comfortable on a younger (but well-funded) codebase. Watch the routing on complex refactors.

For Python-heavy work, also weigh tool-specific tuning over raw agent choice — our AI tools for Python developers piece covers what actually moves the needle there. And if you’re evaluating fully free-software stacks end to end, aifoss.dev tracks the FOSS tooling landscape.

FAQ

Are Kilo Code, OpenCode, and Cline really free? Yes. All three are open source ($0 for the tool) and bring-your-own-key. You pay only for model API tokens, or nothing if you run a local model via Ollama or LM Studio. Kilo additionally sells optional Kilo Pass credit subscriptions, but you can ignore them and BYOK.

Which one is best for running a local LLM? OpenCode has the cleanest setup (ollama launch opencode), Cline has the most community guides and a first-class local picker, and Kilo Code works through any OpenAI-compatible endpoint with optional auto-routing between local and cloud models. For pure ease on a fresh machine, Cline’s GUI picker is the gentlest; for terminal users, OpenCode wins.

Is Kilo Code just a Cline fork? The Kilo Code editor extension descends from Roo Code, which forked Cline — so they share lineage. The separate Kilo CLI is a fork of OpenCode. Kilo’s differentiators (Auto Model routing, Orchestrator, the 500+ model gateway) are what its team built after forking.

Why isn’t Cline or Kilo Code on the Terminal-Bench leaderboard? Nobody has run them through the official tbench.ai harness as of June 2026. OpenCode + GPT-5.5 sits at 83.4% on the native harness. Absence of a score isn’t a low score — but it does mean you can’t compare them on that benchmark.

Do any of these replace Cursor or Claude Code? For BYOK and local use, yes — they cover the same agentic editing and command-running. The trade-off is you manage your own model keys and costs instead of paying a flat $20/mo. If you run heavy agentic sessions, compare token spend against flat-rate plans first.

Sources

• Kilo-Org/kilocode — GitHub repository (stars, license, features)
• Kilo Pass pricing — Kilo official
• Auto Model routing — Kilo docs
• sst/opencode — GitHub repository (stars, license, agents)
• OpenCode + Ollama integration — Ollama docs
• cline/cline — GitHub repository (stars, license, Plan/Act, MCP, local models)
• OpenCode vs Kilo Code comparison — morphllm
• Best AI coding agents leaderboard — morphllm

Last updated June 29, 2026. Pricing, star counts, and features change frequently; verify current state before purchasing or installing.