OpenCode 2.0 Honest Review:

OpenCode is an open source AI coding agent that lives in your terminal, and this month it got a full rebuild. Version 2.0 turns what used to be a single CLI tool into a shared background service that your terminal, desktop, and browser all connect to at once, and it adds parallel background agents plus a new way of calling external tools called Code Mode. It is MIT licensed, model agnostic across 75 plus providers, and it can run completely free on built in models or a local model you host yourself.

This is the honest version, written after reading the official docs, the maker's own notes, the GitHub issue tracker, and what developers are actually saying on Hacker News and in the repo. I will teach you how OpenCode 2.0 works, show you the real commands to try it, and be straight about the rough edges, because there are a few that matter right now.

Prefer the quick version? I covered the full verdict, the one architectural change that matters most, and the early rough edge nobody mentions in this video:

https://youtu.be/izKyryigyQ0

The short version

Before the deep dive, here is what OpenCode is not, because the name confuses people.

• It is not an AI model. It does not compete with Claude or GPT. It is the harness that drives them.
• It is not locked to one provider. You bring your own model, from any of 75 plus providers, or run one locally.
• It is not a paid product with a free trial. The agent itself is free and open source. The only thing you can pay for is the model you point it at, and even that is optional.

The one line mental model:

OpenCode = the harness (reads code, edits files, runs commands)
Your model = the brain you plug in (Claude, GPT, a local Ollama model, or a free built-in one)

In 2.0, that harness stopped being one program and became a service. Here is the shape of it:

  terminal client ─┐
   desktop client ─┼──►  one shared background service  ──►  your model + your tools
   browser client ─┘      (holds sessions, config,
                            permissions, runs the tools)

Every interface you open is just a thin client. The real work, the live session, and the state all sit in one process behind them.

What OpenCode actually is

You give it a task in plain English. It reads your codebase, decides which files to create or change, runs commands, asks permission before the risky steps, and builds the feature. If you have used Claude Code or Codex, it is the same category of tool.

The part that sets it apart is who sits in the driver seat. OpenCode is model agnostic. It uses the Vercel AI SDK and the models.dev catalog to talk to more than 75 providers, so you can run Claude Sonnet for one task and a local model for another without changing tools. It is built by Anomaly, the team formerly known as SST, and the repo sits at well over 200,000 GitHub stars, which puts it at the top of the open source coding agent pile. When OpenCode first hit the front page of Hacker News it pulled over a thousand points, and the most upvoted comments were variations of "finally, a real open source alternative."

That popularity is not just hype. A lot of the pull is efficiency. In one Hacker News thread a developer measured that Claude Code sends around 33,000 tokens before it even reads your prompt, while OpenCode sends around 7,000 on the same task. Your mileage will vary by setup, but the direction is real, and it is part of why people keep reaching for it.

What's new in 2.0, taught clearly

The rebuild changed four things. Here is what each one actually does.

1. A shared background service

In version 1, each interface ran its own engine. In 2.0, there is one central background service, and the terminal, desktop, and browser are all clients of it. It holds your sessions, your config, your permissions, and it runs the tools. So you can start a task in your terminal, then open the same live session in your browser and watch it continue, because there is only one brain and they are all looking at it.

v1:  terminal has its own engine
     desktop has its own engine     (three separate brains)
     browser has its own engine

v2:  terminal ─┐
     desktop ─┼─► one service ─► one live session everyone shares
     browser ─┘

This also opens the door to driving OpenCode from your own scripts, which is what the new API and SDK are for.

2. Background subagents and async shell

Your primary agent can now hand a task to a second agent, even on a different model, and keep working while that agent runs in the background. Shell commands can run async too, so a long test run does not block the conversation. The intended use is reviews, research, and independent work that you want to run alongside the main build. You can also move a running agent into the background with Ctrl+B.

This is the most exciting feature and also the one with the most visible rough edge today. More on that in the caveats section, because it is honest and it is real.

3. Code Mode

This is the most technical change, and it is worth understanding because it is a genuinely clever idea.

MCP, the Model Context Protocol, is the standard that lets an agent connect to external tools and data, like a docs server or an internal API. The normal pattern is sequential. The agent calls one tool, waits, reads the result into its context, calls the next tool, reads that in too, and so on. Every intermediate result gets stuffed back into the model's context window, which is slow and expensive when you are chaining many tools.

Code Mode flips it. Instead of a sequence of tool calls, the agent writes one small JavaScript program that calls several tools, maps the results, and calls the next tool, all in a single round trip. The intermediate values never go back into the model context. Only the final answer does.

Old way (sequential tool calls):
  call tool A ─► result A into context
  call tool B ─► result B into context
  call tool C ─► result C into context      (context balloons)

Code Mode (one round trip):
  agent writes 1 JS program:  A() -> map -> B() -> C()
  runs in a sandbox, only the final result returns to context

The sandbox is locked down on purpose. It has no direct filesystem access, no arbitrary imports, and no timers. It can only reach the tools in your approved catalog (plus fetch for HTTP). So the agent is not writing freehand code on your machine, it is scripting your approved tools.

How much does this save? In one documented real world test, pulling bloated Meta Ads MCP schemas into context, Code Mode dropped the initial context from 177,444 tokens to 54,181 tokens. That is roughly a 69 percent reduction on that case. (You will see a "98 percent" figure floating around from a third party experiment. That number is not OpenCode's and I would not quote it. The documented drop is the 69 percent one.)

4. A rebuilt API, an SDK, and a plugin system

The server API was redesigned for session management and orchestration, down to moving a session into its own git worktree. On top of it sit two packages: @opencode/client to connect to a running service, and @opencode/sdk to embed OpenCode as a library in your own app. There is also a plugin system, where most of the 2.0 features are themselves plugins, they hot reload, and the agent can even write and load its own.

Capabilities and providers at a glance

How to try it in five minutes

Step 1: Install

curl -fsSL https://opencode.ai/v2/install | bash

If you are coming from version 1, upgrade in place instead:

opencode upgrade --major

Step 2: Launch it in a project

cd your-project
opencode

Step 3: Pick a model (this is where "free" happens)

Open the model picker and you will see built in free models you can use with no API key, plus any local model you are running through Ollama, LM Studio, or vLLM, which OpenCode auto discovers. For a hosted model with your own key, run /connect, pick the provider, and paste the key. You can also set it per run:

opencode run --model anthropic/claude-sonnet-4-5 "task"

Step 4: Give it a real task

Build a simple React task app. Users can add tasks, mark them
complete, delete them, and filter by completed and pending.
Keep the interface clean and responsive.

It inspects the project, decides what to create, and asks permission before the important actions.

Step 5: Run a review agent in the background

Use a reviewer subagent to inspect the task app. Check for bugs,
React best practices, unnecessary re-renders, and accessibility
issues. Do not modify files. Return a review summary.

Or move whatever is already running into the background with Ctrl+B and keep prompting.

Step 6 (optional): Open the same session in a browser

opencode pair

This starts a local web server and gives you connection credentials, so you can watch the same live session in your browser next to the terminal.

Code Mode config

Code Mode is on by default for MCP servers. You opt a server in or out with the codemode flag:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "my-remote-mcp": {
      "type": "remote",
      "url": "https://my-mcp-server.com",
      "enabled": true,
      "codemode": true
    }
  }
}

Set codemode to false if you want that server's tools exposed directly to the model instead of going through the execute sandbox.

Is it really free?

Yes, with one honest asterisk. The agent is genuinely free and MIT licensed, so there is no cost for the tool itself. What is not automatically free is the model. Plug in a hosted Claude or GPT with your own key, and you pay that provider per token.

Here is the part people miss. OpenCode ships with a set of free hosted models through its Console that work with no key, and it auto discovers local models you run through Ollama, LM Studio, or vLLM. Either path gives you a capable coding agent for zero dollars. The local path is also fully private and offline, which matters if you cannot send code to a third party. That is the real headline: a serious coding agent you can run completely free, either on the built in models or on your own machine.

OpenCode vs Claude Code vs Codex

One thing I will not claim: that OpenCode writes better code than Claude Code. There is no independent head to head benchmark declaring a winner, and code quality depends far more on the model, the task, and your instructions than on the harness. What OpenCode clearly wins on is flexibility, openness, token efficiency, and how fast it moves.

When to use OpenCode 2.0

1. You want model freedom. Running Claude for hard refactors, a cheap model for boilerplate, and a local model for private code, all in one tool, is exactly what this is for.
2. You want a genuinely free agent. The built in free models and local Ollama path mean you can do real work without a subscription or an API bill.
3. You care about token cost. The lean baseline and Code Mode both cut what you spend on context, which adds up fast on large repos and heavy MCP setups.
4. You live across surfaces. The shared service means starting in the terminal and continuing in a browser is a first class workflow now, not a hack.
5. You want to build on top of it. The SDK and plugin system make OpenCode something you can script, embed, and extend, not just use.

When NOT to use OpenCode 2.0 (the honest part)

1. You need rock solid reliability for production today. Version 2.0 is a fresh rebuild and it shows. If your work cannot absorb a rough edge, Claude Code is the more polished choice while 2.0 settles.
2. You depend on background subagents working perfectly right now. This is the real one, and I will not soften it. See the next section.
3. You are on a low spec or memory constrained machine. The always on service and the TUI are RAM hungry. Hacker News reports of 1GB plus usage are common, and for a terminal tool that is a lot, especially next to Codex CLI running in tens of megabytes.
4. You built heavily on version 1 plugins. The 2.0 plugin and server API is new and churny. Expect to pin versions and fix some plugins on the way up.
5. You want a one click, zero config experience. Setting up models, permissions, and custom agents takes a little time. The flexibility has a setup tax.

What it is not good at, grounded in real reports

This is the section that earns trust, so here are the specific, verifiable rough edges as of this writing.

Background subagents report "done" at spawn. This is the headline rough edge. When you kick off a background subagent, the chip often resolves instantly with no running spinner, while the child session keeps working behind the scenes. The parent is never woken when the child actually finishes, so the real result is stranded until you send another message to collect it. This is tracked first party in anomalyco/opencode issue #48826 ("subagent with pending background work marked completed early, results never collected"), with related reports across the community (zeronsh/zeron #845, multica-ai/multica #1404, Chulf58/sterling #58). It was still reproducible on version 2.1.2, and there is an open fix in flight (PR #57418), so treat this as a known early 2.0 orchestration rough edge that is actively being worked on, not a settled behavior.

Code Mode has a sharp corner too. Because the sandbox has no timers, a never resolving promise inside an execute script can hang a background subagent indefinitely, since there is no built in timeout (anomalyco/opencode issue #56741). Worth knowing before you lean on long running Code Mode scripts.

Memory footprint. Multiple developers report the TUI and the always on service sitting at a gigabyte or more of RAM. That is the cost of the shared service architecture, and it is a real trade off on smaller machines.

The SDK and plugin API are young. The practical advice from the community is to pin your versions and expect churn. It is powerful, but it is not stable yet.

Free tier friction exists. Some features, like custom subagents, have been reported as rejected on the free tier, so "completely free" has edges depending on which features you reach for.

No verified benchmark win over Claude Code. I keep coming back to this because it is the honest center of the whole review. OpenCode is more open, more flexible, more token efficient, and faster moving. It is not proven to produce better code. Those are different claims.

A safer way to evaluate it

If you are going to let an agent touch files and run commands, evaluate it with blast radius in mind.

1. Start in a disposable environment. A throwaway repo or a fresh git branch, not your main project.
2. Give it the smallest workspace that proves the point. Do not point it at a monorepo on day one.
3. Make it plan before it edits. Read the plan, then let it act.
4. Read the diff yourself. Treat generated code like a junior's PR, because that is what it is.
5. Run the tests yourself. Do not trust a "done," especially given the subagent rough edge above.
6. Watch the trace. The shared service makes the session observable across surfaces, so use that to see what actually ran.

What to check before you adopt it

• Model quality: the agent is only as good as the model you plug in. Test your chosen model on your real tasks, not demos.
• Permissions and isolation: confirm what it can run without asking, and tighten it before a big project.
• Code Mode exposure: decide per MCP server whether tools go through the sandbox (codemode: true) or are exposed directly.
• Upgrade cost: if you are on version 1 with custom plugins, budget time for the migration.
• Real cost: running several agents on paid models multiplies your API bill. Free models and local models avoid that, at the cost of some capability.

Final perspective

OpenCode 2.0 = the most open, flexible, fast-moving coding agent
             = free to run (built-in or local models)
             = genuinely clever architecture (shared service + Code Mode)
             = still settling, with real early-2.0 rough edges

Here is what I would actually do. If you want model freedom, token efficiency, or a capable coding agent you can run for free on your own machine, OpenCode 2.0 is worth setting up this week. The shared service, the background agents, and Code Mode are real steps forward, not marketing. If you need something rock solid for production today and you are already happy on Claude Code, stay there for now and check back as 2.0 stabilizes, because the subagent and churn issues are visible and the team is clearly fixing them fast. I would not call OpenCode automatically better than Claude Code. I would call it the most flexible and open option, and the one I would bet on to keep improving quickest.

Official resources

• Repo: https://github.com/anomalyco/opencode
• Docs (v2): https://opencode.ai/v2/docs
• Code Mode and tools: https://opencode.ai/v2/docs/tools/
• Models and providers: https://opencode.ai/v2/docs/models/
• Migrate from v1: https://opencode.ai/v2/docs/migrate-v1/
• Maker's notes: https://anoma.ly/notes/opencode-2-0/

Have you tried OpenCode 2.0 yet? Tell me in the comments whether you are on Claude Code, Codex, Cursor, or OpenCode, and whether you would switch. If you like quick, honest AI tool reviews, follow the GoVenture YouTube channel for the next one.