OpenCode

The AI coding agent market consolidated fast around a small number of closed products, each tied to a specific model provider, each sending your code to a service you do not control.

For a large share of developers that is entirely fine. For anyone working under a client NDA, in a regulated industry, on proprietary code with strict handling rules, or simply unwilling to bet their workflow on one vendor's pricing decisions, it is not.

OpenCode is the credible open source answer to that, and it has become one of the most starred projects on GitHub in the process. This review covers what model-agnosticism actually buys you, why the client-server architecture is more interesting than it sounds, how the free-and-paid split works, and where Cursor remains the better tool.

Open Source, Terminal-Native

• OpenCode is an open source AI coding agent that runs in your terminal, with desktop and IDE clients available, released under the MIT licence.
• It is model-agnostic by design — over 75 providers, including Claude, GPT, Gemini and local models, with the option to authenticate through an existing GitHub Copilot or OpenAI subscription.
• Privacy is architectural rather than promised. Conversations are stored locally in SQLite, and the vendor states no code or context is retained on their side.
• It is built by the team behind SST, with the project's own counter showing well over 195,000 GitHub stars, 950 contributors and 13,000+ commits at the time of this check.
• The core is free. A separate paid service, Zen, offers a curated set of models benchmarked for coding agents, plus an enterprise tier.

Model Agnosticism Is The Whole Design

Support for 75+ providers is the headline number and it understates the point, which is not choice for its own sake.

Coding agents are now competent enough that the model is no longer the deciding factor for most work. What differs is cost, latency, context window, and how each model behaves on your particular codebase — and those change every few months as new releases land.

A tool locked to one provider means you re-evaluate your entire workflow whenever the landscape shifts. A tool that treats the model as a swappable component means you change a setting.

There are three specific cases where this matters more than convenience. Local models mean code never leaves the machine, which is the only acceptable configuration in some environments. Cost control means routing routine work to a cheap model and hard work to an expensive one. Continuity means a provider outage or a pricing change is an inconvenience rather than a crisis.

The ability to authenticate through an existing GitHub Copilot or OpenAI subscription is a practical touch worth noticing. It means developers whose employers already pay for one of those can use this agent without a second procurement conversation, which is often the real barrier to adoption inside a company.

The trade-off is that a tool supporting everything is optimised for nothing. A closed product tuned tightly to one model can extract more from it than a general client will.

The model stopped being the differentiator two years ago. What you are actually choosing now is who controls the tool and where your code goes.

Local Storage And The Client-Server Split

Two architectural decisions do more for real-world usefulness than any feature on the list.

Conversations are stored locally in SQLite. That is a meaningful difference from a promise about data handling — there is no server holding your session history because the history is a file on your disk. For anyone whose code cannot leave the building, an architecture that makes retention impossible is worth more than any policy page.

It also means your history is yours: greppable, backup-able, and not subject to a retention schedule someone else sets.

The client-server split is the more interesting one. The agent runs where your code is and can be driven from elsewhere — a mobile client, another machine, a shared session link.

That enables things a locally-bound tool cannot. Starting a long-running task on your workstation and checking it from a phone. Running the agent on a remote development machine while driving it from a laptop. Sharing a session with a colleague so they can see what the agent did rather than being told about it.

Other open source agents — Aider and Cline — make different trade-offs on this. Automatic LSP configuration is the quieter quality signal. Language server integration is what gives an agent real understanding of types, definitions and references rather than treating code as text — and configuring it manually is exactly the friction that makes people abandon a tool in week one.

What MIT Licensing Actually Changes

Open source is used loosely in this market, so it is worth being precise about what is on offer here.

MIT is a genuinely permissive licence. You can read the code, modify it, run it on your own infrastructure, fork it, and use it commercially without asking anyone. There is no source-available licence with a non-compete clause, and no free tier that becomes a paid one at a certain company size.

The practical consequences are concrete rather than ideological. Auditability: a security team can read exactly what the agent does with your code, which is frequently the condition for approval in a regulated environment. Self-hosting: the whole thing can run inside your own network. Longevity: if the company changes direction or disappears, the code continues to exist and can be forked.

That last point deserves weight given how this market has behaved. Developer tools have been acquired, repriced and discontinued repeatedly, and a workflow built on a closed tool is exposed to all of that. A permissive licence is insurance against decisions made by other people.

The counterweight is the ordinary open source one: support is community-based rather than contractual. There is a paid enterprise tier for organisations that need more, and for individual developers the answer to a problem is a GitHub issue rather than a support ticket with an SLA.

1. Install it alongside your current tool rather than replacing anything.
2. Point it at a model you already pay for, via an existing Copilot or OpenAI subscription if you have one.
3. Give it a task in a real repository, not a toy one — agents diverge most on unfamiliar codebases.
4. Check that LSP configured itself correctly for your language before judging quality.
5. Try a local model on something confidential, since that is the capability closed tools cannot offer.

Free, And What Is Not

This site does not publish plan prices. OpenCode's structure is unusual and worth setting out clearly, because free here means several different things.

The agent itself is free and open source under MIT. There is no paid tier of the tool, no seat limit, and no feature held back.

Model usage is not free, and this is the part people miss. You bring your own provider credentials and pay whoever serves the model — or point it at a local model and pay nothing but electricity. Agentic coding consumes tokens heavily, because the agent reads files, plans, revises and retries. Budget for the API bill rather than assuming free software means free operation.

Zen is the paid service, offering a curated set of models the team has tested and benchmarked specifically for coding agents. That is a genuinely sensible product: choosing between 75 providers is a burden, and paying someone to have done the evaluation is a reasonable trade.

An enterprise tier exists for organisations with privacy-sensitive requirements, which is where support commitments and deployment assistance live.

The honest budgeting comparison against a closed competitor is not licence against licence. It is your model spend plus zero licence cost, against a flat subscription with model usage included — and which wins depends entirely on how heavily you use it.

Where A Closed Tool Still Wins

Being specific here is more useful than advocacy, and the honest answer is that plenty of developers should use something else.

Integrated editing experience. Cursor and similar tools are built around the editor, with inline diffs, tab completion and a visual review flow that a terminal agent does not replicate. If you think visually about code changes, that difference is substantial.

Zero configuration. A closed product like Windsurf, with one model and one account, is simpler. OpenCode's flexibility is configuration, and configuration is work.

One bill, one vendor. Bringing your own keys across multiple providers means managing credentials and reconciling several invoices. A single subscription is administratively simpler, which matters more in a company than to an individual.

Contractual support. Community support is genuinely good on a project this size, and it is not an SLA.

The reasonable position is that these are complementary rather than competing. Many developers run a terminal agent for long-running autonomous tasks and an editor-integrated tool for interactive work, and there is no reason to pick only one.

• Cursor and editor-first tools win on inline diffs and visual review
• Closed products win on zero configuration and a single bill
• OpenCode wins on local models, self-hosting and auditability
• OpenCode wins on not being exposed to one vendor's pricing decisions
• Running both is a perfectly reasonable answer

Licence, Providers And Project Scale

Other Coding Agents Worth Trying

Most developers end up running two of these — one for interactive editing, one for longer autonomous tasks.

• Cursor — the editor-first alternative, with a stronger visual review flow
• Aider — the other established open source terminal agent
• Cline — open source agent living inside VS Code
• Windsurf — editor-integrated agentic coding
• GitHub Copilot — the subscription many teams already hold and can authenticate with