OpenCode vs Claude Code: An Honest Comparison (2026)

What is the difference between OpenCode and Claude Code?

OpenCode is an MIT-licensed coding agent that runs whichever model you point it at, and Claude Code is Anthropic's proprietary agent that runs Claude. Everything else in this comparison follows from that one split: who owns the code, who picks the model, and who sends you the bill.

Both do the same job. You describe a change in plain language, the agent reads your repository, edits files, runs commands, and hands you a diff or a pull request. On that job they are close enough that arguing about which one is "smarter" mostly means arguing about which model you gave it.

This piece stays on the parts that do not move: licence, model routing, billing shape, where each one runs, and how each behaves on a pull request. Every number below was read from a primary source on 14 August 2026, and the GitHub counts move daily, so treat them as a dated snapshot rather than a live scoreboard.

Which OpenCode repo is the real one?

The live project is anomalyco/opencode, and a surprising amount of the internet is still describing the other one. There are two repositories with that name, and the one most search summaries quote has been archived since September 2025.

The archived repo, opencode-ai/opencode, is written in Go and stopped at 13,649 stars with a final push on 18 September 2025. GitHub marks it read-only. The live repo, anomalyco/opencode, is TypeScript, MIT-licensed, and was pushed to on the day this article was written. It carries 197,498 stars and 25,417 forks — roughly top-fifteen territory on GitHub, well behind list repos like sindresorhus/awesome at around 496,000, but far past the threshold where a project is a curiosity.

There is a third address in the mix, too: github.com/sst/opencode, where the project lived before the org rename. That URL now answers with an HTTP 301 to anomalyco/opencode, so old links still work, but the stale org name keeps circulating in write-ups and package docs.

Why this matters beyond trivia: if a comparison tells you OpenCode is "a Go TUI with around 13k stars," it is describing a project nobody has shipped to in close to eleven months, and everything downstream of that sentence — the feature list, the provider support, the release pace — is about the wrong software.

Who actually controls each agent?

OpenCode ships under MIT and Claude Code does not ship its source at all. That is the cleanest line between them, and it decides more than most people expect when they first compare feature lists.

With OpenCode you can read the agent loop, patch a tool call that annoys you, pin your team to a commit, and keep running it if the company behind it changes direction. Over 450 people have contributed. The 25,417 forks are not decoration; that is the escape hatch working as intended.

Claude Code's public repository is a different kind of artefact. anthropics/claude-code holds the changelog, the issue tracker, plugins and examples, and its LICENSE.md is a single line: "© Anthropic PBC. All rights reserved. Use is subject to Anthropic's Commercial Terms of Service." The 141,461 stars on it measure how many developers wanted to follow the project, not how much code they can fork.

Neither position is wrong. A closed agent with one vendor accountable for it is a perfectly reasonable thing to buy, and plenty of teams prefer a supported path over a patchable one. The mistake is picking a tool on model quality and discovering the licence six months later, when a pricing change or a deprecation lands and one of the two options leaves you with no move.

Which models can each one run?

OpenCode routes to 75+ providers, Claude Code routes to Claude. OpenCode's provider documentation says it uses the AI SDK and Models.dev to reach that list, which spans Anthropic, OpenAI, Groq, DeepSeek, Cerebras, Together, xAI, Amazon Bedrock, Azure OpenAI, Google Vertex AI, Hugging Face, OpenRouter and more, plus local runtimes through Ollama, LM Studio and llama.cpp.

The practical version of that freedom is per-task switching. You run a cheap fast model while you are exploring a codebase, then switch to an expensive one for the change that actually ships, and the agent around them does not change. Teams working under a data policy that forbids sending source to a third party get the other half of it: point OpenCode at a local model and nothing leaves the machine.

Claude Code takes the opposite bet and it is a coherent one. Opus, Sonnet, Haiku and Fable, the top tier documented for the hardest and longest-running tasks, are tuned alongside the harness that drives them, so the model-switching decision mostly disappears. What varies is the billing route, not the model: Anthropic direct, Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, or Microsoft Foundry, each with its own credentials and cost dashboard.

There is a middle path that gets overlooked. OpenCode's docs list ChatGPT Plus, GitHub Copilot and GitLab Duo as subscriptions you can use "with zero setup," so a developer already paying for a Copilot seat can fund an OpenCode habit without opening a new billing relationship.

One subscription is missing from that list, and the reason is worth knowing before you go looking for a workaround. A Claude Pro or Max plan cannot fund OpenCode, and it is OpenCode's own provider documentation that says so: "There are plugins that allow you to use your Claude Pro/Max models with OpenCode. Anthropic explicitly prohibits this. Previous versions of OpenCode came bundled with these plugins but that is no longer the case as of 1.3.0." They shipped that capability, pulled it, and left the warning standing where users will hit it. Claude models inside OpenCode means an Anthropic API key billed per token, and if your Claude budget is already a subscription, that is a second bill rather than the same one.

What does each one cost?

OpenCode charges nothing for the agent and everything for the tokens; Claude Code charges for a plan that already includes the tokens. Comparing the headline numbers without that distinction is how people end up surprised in month two.

There is no licence fee, no seat price and no free tier to age out of, because there is nothing to buy. Your bill is whatever provider you connected. If you would rather not manage keys across five vendors, OpenCode Zen is their own gateway with a curated model list, charged per request against a balance you top up, and their docs list several models at no cost.

Claude Code is included in the Claude subscription rather than sold separately, and this is the single most misquoted fact in the category. Read from claude.com/pricing on 14 August 2026: Free is $0, Pro is $20/month or $17/month billed annually at $200 upfront, Max starts at $100/month with 5x and 20x usage tiers billed monthly, and a standard Team seat is $25/month or $20/month billed annually. Anthropic's pricing FAQ puts the boundary at the paywall — "Claude Code is included in all paid plans" — and the setup docs say the free tier plainly: "The free Claude.ai plan does not include Claude Code access." Team has a second seat type too, a Premium seat at $100/month, and that is the one Anthropic's page attaches the Claude Code bullet to. So it is not a standalone $100/month product, and any article that says so has copied a Max plan price into the wrong column. But "free" is not the answer either.

Two cost effects only show up after a month of real use. The first is the idle floor: OpenCode costs $0 in a week you do not touch it, while a seat bills whether or not anyone opened a terminal. The second is the ceiling, and it is softer than the usual telling. A subscription cap does stop you and make you wait, where pay-per-token just keeps spending through an agent stuck in a loop at 2am. But the cap is opt-out: Anthropic's FAQ says that on paid plans you can turn on usage credits and keep working at standard API rates, which puts you back on the meter. Managed Code Review, discussed below, bills that way by default. So the real question is not which model has a ceiling — it is whether anyone on your team has quietly switched it off.

Where does each one run?

Each one starts in a terminal, then diverges on how many other places it shows up. OpenCode leads with a TUI, adds a VS Code extension that installs itself the first time you run opencode in the integrated terminal, and serves a browser UI with opencode web on localhost. It also exposes a server, an SDK, an ACP endpoint and a plugin system, which is why it turns up embedded in other people's tools.

Claude Code spreads wider on the client side. The docs list a terminal CLI, a VS Code extension, a JetBrains plugin for IntelliJ and friends, a Code tab inside the Claude desktop app on macOS, Windows and Linux in beta, a browser experience at claude.ai/code, and iOS and Android through the Claude app. Sessions move between surfaces, which is a real convenience if you regularly start something at a desk and check on it from a phone.

The distinction that matters for a locked-down environment is who hosts the surface. OpenCode's browser UI is a local server you start yourself, binding to 127.0.0.1 by default. Claude Code's web and mobile surfaces run on Anthropic's infrastructure, and its docs are explicit that most surfaces need a Claude subscription or a Console account.

How does each one review a pull request?

Both can comment on a PR, but one is a managed service you switch on and the other is a workflow file you own. This is the section where the two tools stop resembling each other.

Claude Code's Code Review is a hosted product. An organisation Owner installs the Claude GitHub App, picks repositories, and chooses whether reviews run once per PR, on every push, or only when someone comments @claude review. A fleet of agents analyses the diff against the full codebase on Anthropic's infrastructure, a verification step filters candidates, and findings post as inline comments tagged Important, Nit or Pre-existing. The check run always completes neutral, so nothing blocks a merge.

The constraints are stated plainly in Anthropic's own docs, and they are the part worth reading twice. Code Review is in research preview and available only to Team and Enterprise subscriptions. It is unavailable to organisations with Zero Data Retention enabled. Reviews average around 20 minutes. And it is billed by token usage: "Each review averages $15-25 in cost," charged to usage credits separately from the plan's included usage. On a repository merging ten PRs a week with reviews on every push, that is a line item worth modelling before you flip it on.

OpenCode's route is a GitHub Action you install with opencode github install or wire up by hand. It runs inside your own Actions runner with keys from GitHub Secrets, and it responds to /oc or /opencode in a comment. The behaviour most people miss is in the pull_request trigger: OpenCode's docs state that for pull_request events, if no prompt is provided, it defaults to reviewing the pull request. You get a reviewer for the price of a workflow file, your Actions minutes and your own tokens.

There is also a local move on both sides that costs nothing to try. opencode pr <number> fetches and checks out a GitHub PR branch and then starts the agent on it. Claude Code's /code-review command reviews a diff in your terminal without installing any GitHub App, and unlike the managed service it is not restricted to Team and Enterprise plans.

How fast is OpenCode moving?

Fast enough that the backlog is part of the deal. OpenCode published 23 releases in the 30 days before this article, four of them in the final week, with v1.18.18 dated 13 August 2026. That pace is unusual for a project of this size and it is the strongest argument for the open model: a bug you report has a real chance of being fixed this week.

The same repository carries 3,941 open issues and about 1,300 open pull requests. Those two figures describe one situation rather than two. A project shipping most working days to a user base large enough to generate 197k stars will always have a queue, and the queue is a consequence of the reach, not evidence of neglect.

What it means in practice is that OpenCode asks for a version policy. Auto-update is on by default, and a config that worked on Tuesday can behave differently on Thursday. Teams that care about reproducibility pin a version and upgrade deliberately, which the CLI supports directly through opencode upgrade [target].

Claude Code moves quickly too, and it manages the same problem differently. Native installs update in the background, and Homebrew ships two casks — a stable channel roughly a week behind that skips releases with major regressions, and a latest channel. Picking the release channel is the version policy, which is less control and less work.

Which one is more widely used?

The honest answer is that nobody outside the two companies knows, and the metric everyone quotes is broken. The usual move is to line up npm downloads: for the 30 days ending 9 August 2026, the npm registry reports 8,643,056 downloads for opencode-ai against 48,011,970 for @anthropic-ai/claude-code. That looks like a 5.6x gap.

It is not a 5.6x gap in users, and the reason is printed in Claude Code's own README: "Installation via npm is deprecated." Anthropic steers people to a curl script, Homebrew or WinGet, so npm counts a shrinking and self-selected slice of its installs. OpenCode has the same problem in reverse, with install paths through curl, Homebrew, pacman, Chocolatey, Scoop, mise and a Docker image, none of which npm sees.

CI is the other distortion. Every workflow run that installs an agent counts as a download, so a single busy repository can outweigh hundreds of humans. Star counts have the opposite bias: they are cheap and permanent, and they reward whichever project had the better launch week.

Serious adoption is not in doubt for either one, and both are maintained daily, so neither is a risky bet on those grounds. If you want a number that predicts anything about your own team, measure PRs merged per developer per week before and after, on your repositories. Download counts predict nothing about that.

When does each one break?

Every comparison lists strengths. The failure cases decide more, and these are the ones that show up repeatedly in practice.

OpenCode's provider freedom is also its configuration surface. Seventy-five-plus providers means as many ways for a model ID, a base URL or a credential to be wrong, and the error you get is usually the provider's, not the agent's. Fixing it means knowing which layer failed.

Model quality does not carry across the switch. An agent harness tuned against one model family will behave differently on another. Switching to a cheaper model to save money often just moves the cost into retries and abandoned sessions.

Claude Code's managed Code Review has a plan floor. It is Team and Enterprise only and in research preview, so a solo developer or a Pro subscriber cannot buy it at any price. The local /code-review command is the available substitute, and it is not the same product.

Per-review billing scales with the wrong thing. At an average of $15-25 per run with reviews on every push, an active PR that gets eight pushes costs more than a quiet PR that gets one — even though the noisy PR is often the small one.

Neither one is a review gate. Both agents write code and both can be asked to critique code, but an agent reviewing a diff it produced is a single opinion checking itself. That limitation is architectural, and no amount of prompt tuning removes it.

Where does a review layer fit?

A coding agent's job ends at the diff, and somebody still has to decide whether the diff is right. DORA's State of AI-assisted Software Development 2025 report puts the underlying pattern well: AI's primary role, they found, "is as an amplifier, magnifying an organization's existing strengths and weaknesses." A team with a real review habit gets faster. A team without one gets more unreviewed code, faster.

The gap is not about model quality. It is about who is doing the checking. When the same agent that wrote a change is asked to review it, you get one perspective evaluating its own assumptions, working from the same context that produced the bug. A second model reading the finished diff without that history catches a different class of problem, which is the same reason human teams do not let authors approve their own PRs.

We built Git AutoReview to sit in that gap rather than compete for the writing job. It runs inside VS Code, reads the pull request on GitHub, GitLab or Bitbucket, and posts nothing until you approve it. Findings arrive as drafts in the editor, you keep, edit or delete each one, and only then does anything reach the thread. If you want the deeper pass, Deep Review explores the whole project — imports, configs, tests — instead of only the changed lines, which is how cross-file breakage from an agent's refactor gets caught.

The billing model is deliberately the same shape OpenCode users already prefer. Git AutoReview is BYOK: you bring a key from Anthropic, Google or OpenAI, or an existing Claude Code or GitHub Copilot subscription, and that provider bills you directly at roughly $2-5/month for daily reviewing. The subscription sits on top — Free at $0 for 10 reviews a day on one repository, Developer at $9.99/month, Team at $14.99/month. An API key is required for reviews to run at all, so budget both lines. What you get for the split is a data path with nobody in the middle: the diff goes from your editor to the provider you chose and stops there.

Which one should you pick?

Pick on billing shape and model freedom, because those are the two things you cannot change later without changing tools.

Take OpenCode if you want to switch models per task, if a local or self-hosted model is a requirement rather than a preference, if your budget is metered rather than per-seat, or if being able to read and patch the agent matters to your team. The cost of entry is a config file and a version policy.

Take Claude Code if you already pay for Claude Pro, Max or Team, because the agent is already in that price. Take it if you want one supported path instead of a provider matrix, if a JetBrains plugin or the mobile app fits how you work, or if you want a managed PR reviewer you can buy rather than assemble.

Running both is normal and nobody will stop you. They are CLIs in a terminal, they read the same repositories, and plenty of developers keep one for exploration and the other for the change that ships. The question that actually needs an answer is not which agent writes your code — it is what reads the code before it merges. If the answer is the same agent that wrote it, that is the gap worth closing first.

For a wider view of the CLI field, Claude Code vs Gemini CLI for code review covers the two terminal agents head to head, and diff bots vs agentic review explains why the review layer works differently from the writing layer. If you are on a VS Code fork such as Cursor or VSCodium, installing from Open VSX covers the registry split that catches people out.

* Subscription price only. AI compute is billed to you by the provider you choose, because your code goes straight from VS Code to them and never touches our servers. Bundled-compute tools such as CodeRabbit include that cost in their per-user price.

Related resources

• Claude Code vs Gemini CLI for code review — the two terminal agents compared on review specifically
• How to use Claude Code for code reviews in VS Code — the manual workflow, prompts and limits
• Diff bots vs agentic review — three generations of AI review and what each catches
• Deep Review: the agent that reads your whole project — how full-project context changes what gets found
• Code review checklist for AI-generated code — 12 items that matter more when an agent wrote the diff
• AI code review in Cursor, VSCodium and Devin Desktop — installing in a VS Code fork
• AI API pricing calculator — per-model cost on your actual review volume