OpenCode Review 2026: What the Free Open-Source Coding Agent Actually Costs

OpenCode is free, MIT-licensed, and genuinely open source — and none of that tells you what it costs to run. The software is free; the intelligence is not. OpenCode is a terminal client that drives somebody else's model, so your monthly bill is whatever tokens you burn at Anthropic, OpenAI, or whoever else you point it at. That distinction is the whole financial story of this tool, and the homepage doesn't lead with it.

What it actually does

OpenCode lives in your terminal. You point it at a project, describe what you want, and it reads files, edits them, runs commands, and reports back. If you've used Claude Code or Codex, the shape is familiar: an agent with filesystem and shell access, working inside a session you can interrupt.

The design difference is that OpenCode is deliberately not tied to any model. Anthropic makes Claude Code to run Claude. OpenAI makes Codex to run GPT. OpenCode is made by neither, and connects to 75+ providers through the Models.dev directory — including local models via Ollama or LM Studio, if you'd rather nothing leave your machine at all.

Two features are worth calling out because they're not universal in this category:

LSP integration. OpenCode hooks into Language Server Protocol servers — Pyright for Python, rust-analyzer for Rust, gopls for Go, and around twenty more. In practice this means the agent sees real type information and live compiler diagnostics rather than inferring them from the text of your files. When it writes something that doesn't typecheck, the error comes back to the model mid-task and it corrects before telling you it's done. This is the most technically interesting thing in the product.

Plan mode and build mode. Plan mode reasons about a change without touching files. Build mode executes. The separation matters more than it sounds like it should, because the expensive failure with coding agents isn't a bad suggestion — it's a confident twenty-file refactor you didn't ask for.

What it actually costs

Nothing, and then something. The client is MIT-licensed with no paid tier, no seats, and no telemetry-for-features bargain. But every request goes to a model, and models bill per token.

You have three ways to pay for that:

Reported real-world spend for heavy daily use on a frontier model lands somewhere around $20–50/month in API costs — which can exceed a flat Copilot subscription. If you already pay for Claude Max or ChatGPT Pro, authenticating OpenCode against that subscription is the obvious first move, and it makes the tool genuinely free at the margin.

Before you go searching for it: there are two OpenCodes

This will cost you time if nobody warns you, so here's the warning.

In mid-2025 the original OpenCode project went through a public and fairly ugly split. Charm — the company behind the Bubble Tea and Lip Gloss terminal libraries — brought the original creator and the repository under its organisation. Other major contributors, who held the opencode.ai domain, objected. Accusations flew about rewritten git history and banned critics. It resolved with Charm renaming their version Crush, while the remaining team kept the OpenCode name and rewrote the project in TypeScript.

The practical consequences for you today:

• The current repo is anomalyco/opencode. Older links point at sst/opencode and redirect; older tutorials may reference a Go codebase that no longer exists.
• Crush is a different, actively maintained product from Charm with a notably prettier interface. If you're comparing terminal agents, it belongs on your list.
• Tutorials and benchmarks written before roughly August 2025 may describe either project. Check which one before you trust the conclusions.

The split is now old news and both projects are healthy. It just makes searching unusually noisy, and it's the single most common way people get confused about this tool.

The speed problem, and why it might be a feature

This is the finding that should shape your expectations. In DataCamp's head-to-head testing, OpenCode completed a four-task benchmark in 16 minutes 20 seconds against Claude Code's 9 minutes 9 seconds — roughly 78% slower on the same underlying model.

That is a large gap and it is not a rounding error. But the reason is interesting. OpenCode is slower largely because it insists on doing things Claude Code skips: reinstalling dependencies, running the full test suite rather than a subset, and generating more tests. The same testing found OpenCode produced about 21 more tests on average and raised test coverage by around 29%.

So the honest framing isn't "slower tool." It's a different default on a real trade-off. Claude Code optimises for you getting an answer; OpenCode optimises for the answer being verified before you see it. Whether that's worth doubling your wait depends entirely on whether you were going to run those tests yourself.

My read: for exploratory work and small edits, the wait is annoying and Claude Code's defaults are better. For anything touching code you'd have to review carefully anyway, OpenCode's thoroughness is buying you something real. You can also configure a lot of this — the defaults are a philosophy, not a hard limit.

What the repo tells you that the homepage doesn't

Open source means the health metrics are public, so there's no need to take anyone's word for anything. As of July 2026:

• ~187,000 stars and ~23,500 forks. Genuinely enormous for a fifteen-month-old project, and it makes OpenCode the most-starred open-source coding agent by a wide margin.
• ~4,700 open issues. This is the number worth pausing on. It's not necessarily a red flag — a project this popular generates issues faster than any team can close them, and many are feature requests rather than defects. But it does mean that if you hit a bug, you are joining a long queue.
• Commits landing daily. The project is actively maintained, not a popular-but-abandoned repo, which is a failure mode worth checking for in any open-source dependency.
• MIT licensed. No commercial-use restriction, no relicensing surprise, no CLA drama. You can fork it and ship it.

The claim I couldn't verify is the "7.5 million developers monthly" figure on the homepage. There's no published methodology for it and no independent source. It may well be accurate — download counts across a dozen package managers are hard to audit either way — but treat it as marketing rather than measurement. The star and fork counts are checkable and impressive enough on their own.

How it compares

The category is crowded and moving fast. What OpenCode has that the proprietary options structurally cannot is the ability to switch models when one gets worse, more expensive, or discontinued — without switching tools. In a market where model pricing has changed repeatedly in eighteen months, that's not a small hedge.

Who it suits — and who should skip it

Worth installing if: you're comfortable in a terminal, you already pay for Claude or ChatGPT and want more from that subscription, you work somewhere that needs an auditable toolchain, or you specifically want the LSP integration — which no proprietary competitor currently matches.

Probably skip if: you want something that works in five minutes with no configuration (Copilot or Cursor will serve you better), you need predictable flat billing rather than variable token spend, you don't work in a terminal by preference, or you're new enough to programming that you can't yet review what an agent hands you. That last one applies to every coding agent, but it applies harder to one whose defaults let it run your test suite and reinstall your dependencies.

How to evaluate it in an afternoon

It's free and installs in one command, so evaluation costs you time rather than money. Five things worth doing deliberately:

1. Connect your existing subscription first, not an API key. Run /connect and authenticate against Claude, ChatGPT, or Copilot if you have one. This tells you whether the tool is useful before you've spent a cent, and stops an exploratory session turning into a surprise invoice.
2. Test the LSP integration on purpose. Ask for a change in a strongly typed file and watch whether it catches its own type errors before reporting done. This is the headline feature — confirm it works in your language, since LSP quality varies a lot across the twenty-plus supported.
3. Time one real task against your current tool. The 78% figure is someone else's codebase. Find out what the gap looks like on yours, and whether the extra tests it writes are ones you'd have written.
4. Use plan mode before build mode on anything non-trivial. Read the plan. This is where you catch a misunderstanding for free instead of reviewing a diff for it.
5. If you're evaluating for work, check the model terms, not the tool's. OpenCode itself stores nothing. But the provider you connect it to has its own retention policy, and the Zen free models explicitly may use your data. The tool's privacy posture is only as good as the endpoint you point it at.

The bottom line

OpenCode is the most credible tool I've looked at on this site, and the reason is structural rather than a matter of taste: everything it claims can be checked. The licence is MIT, the repo is public, the issue count is visible, the model prices are published, and an independent benchmark says plainly that it's slower than its main competitor. Very few AI products let you verify the unflattering parts.

It's not the right pick for everyone. It's slower, it assumes terminal fluency, and "free" is doing some real work in the marketing given that you still have to pay for tokens. If you want to open something and have it work, buy Copilot.

But if you're going to be paying a model provider anyway, and you'd rather not have your tooling welded to whichever lab is currently winning, this is the one to install. The switching cost when the market moves again is close to zero — and on current evidence, the market will move again.

Frequently asked questions