OpenCode vs Claude Code: Open Source Agent or Managed One

The Two Bets

OpenCode bets that the agent should be neutral and the model should be swappable. Claude Code bets that a tightly integrated agent and model, available everywhere you work, is worth giving up that neutrality for.

Both bets are coherent. They just fail in opposite directions.

• OpenCode fails towards assembly - you own the provider keys, the model choice, and the consequences of a bad pairing between them.
• Claude Code fails towards dependence - the roadmap, the pricing model, and the model lineup are all decided somewhere other than your repository.
• Neither fails towards code quality - the output gap between frontier models running the same task is far narrower than the workflow gap between these two tools.

What the Public Numbers Say

Only one side of this comparison publishes a repository, so the measurable facts are asymmetric. That asymmetry is itself the finding.

Read the right-hand column carefully before treating it as a weakness. Five of those rows are blank because managed software does not expose them, not because the product is worse.

What it does mean is that due diligence works differently on each side. One you audit by reading, the other you audit by contract.

Feature by Feature

Every row below comes from the vendors' own documentation, checked this session rather than recalled.

Two rows carry most of the decision. The interface row explains why Claude Code users rarely leave, and the hooks row explains why teams with compliance requirements end up there.

Where the Two Diverge Most

Not on features, on enforcement. OpenCode gives you inspectability, and Claude Code gives you a mechanism that runs whether or not the model cooperates.

That distinction decides more architectures than any benchmark. An instruction file is advisory in both tools.

Only one of them ships a lifecycle event you can bind a shell command to, which is what makes a rule hold on turn two hundred as reliably as on turn one. We went through that mechanism in detail in Claude Code hooks.

OpenCode's answer to the same problem is different in kind. Because the agent runs one shot and can emit raw JSON events, you wrap it from outside instead of hooking it from inside.

# OpenCode: enforcement lives in the wrapper, because the process is scriptable
opencode run --format json "add rate limiting to the login endpoint" \
  | tee run.jsonl

./verify.sh || { echo "verification failed, not committing" >&2; exit 1; }

# Claude Code: enforcement lives inside the session, because Stop fires on its own
# .claude/settings.json -> hooks.Stop -> command -> ./verify.sh

Both reach the same place. The difference is that the wrapper only protects the runs you remembered to wrap.

How You Verify What Either One Built

Almost every comparison of these two argues about which writes better code. None of them ask the question that decides whether either is safe to run unattended.

A passing build proves the code compiles. It does not prove the button renders, the redirect lands, or the form still submits.

The useful property here is that the verification layer does not have to pick a side. Kane CLI from TestMu AI is a shell command that takes a plain-English objective, drives real Chrome, and returns a POSIX exit code, so it plugs into an OpenCode wrapper and a Claude Code hook without changing a character.

• Agent-neutral by construction - it is a process with an exit status, so anything that can run a command can gate on it.
• Distinct failure states - 0 passes, 1 is a failed assertion, 2 is an environment error, and 3 is a timeout, so a Chrome crash never reads as a broken feature.
• Evidence, not a claim - each run seals a pack with per-step screenshots, a HAR network log, and console output under .testmuai/evidence in the repository.
• No selectors to keep alive - the objective names what a user sees, so a class rename does not turn the gate red.

Here is a real run against the TestMu AI ecommerce playground, on Kane CLI 0.8.4, in the agent mode both wrappers would call.

$ kane-cli run --agent --headless \
    "search for 'iPhone' in the site search box, submit the search,
     and assert the results page lists at least one product" \
    --url https://ecommerce-playground.lambdatest.io/ | tail -1

{"type":"run_end","status":"passed",
 "summary":"Searched for 'iPhone' using the site's search box. Opened the search
            results page for iPhone. The results page showed at least one product.",
 "final_state":{"search_query":"iPhone","results_found":"true"},
 "reason":"Objective completed","duration":29.8,"bifurcated":false,"total_runs":1}

$ echo $?
0

An OpenCode wrapper reads that exit status after the run. A Claude Code Stop hook reads the same status from inside the session. The command in the middle is identical.

Setup and the full command reference live in the Kane CLI introduction documentation.

The Shape of the Cost

Comparing headline prices here is the wrong exercise, because the two do not bill for the same thing.

• OpenCode charges you nothing and your provider charges you everything - the client is free, and every token goes through keys you hold and invoices you already receive.
• Claude Code bundles the model with the tool - Anthropic's documentation states most surfaces require a Claude subscription or a Console account, so the agent and the inference arrive together.
• Predictability moves in opposite directions - a subscription is easier to forecast, and metered provider keys are easier to attribute per team.
• The unpriced cost is operational - somebody maintains the OpenCode wrapper, the provider key rotation, and the model pinning, and that time is real.

Model your own numbers rather than quoting anyone's. Both vendors change pricing more often than any article can track.

Which One Should You Use

Pick OpenCode if you need to read the agent, swap models, or keep inference on keys you control. Pick Claude Code if you need one session across five surfaces and rules that fire without the model's cooperation.

Three situations decide it cleanly.

• Your security review requires reading what runs against the repository, which only the MIT-licensed client permits.
• Your team needs a rule enforced on every turn without exception, which only lifecycle hooks deliver.
• Your work moves between a laptop, an IDE, and a browser during a single task, which only the multi-surface product carries.

If none of the three apply, run both for a fortnight on real tickets and keep the one your team stops complaining about. They are cheap to try and expensive to argue about.

For the wider field these two sit in, our roundup of agentic coding CLI tools ranks nine of them on adoption and CI maturity. And for a comparison on the managed side of the fence, Claude Code vs Antigravity covers the two that most often shortlist together.