🎯 Two questions, not one 0:00
The video opens by refusing the framing almost every other comparison uses. Running the same Claude model in two harnesses on the same repo with the same prompt is not one test — it is two: is the harness better, and is the bill better? Those answers can point in opposite directions, and the video's conclusion is that for most people on a Claude subscription they do.
The facts that frame it: OpenCode 2.0 shipped on 12 October 2026, the repository (anomalyco/opencode, MIT) sits at 223,260 stars — the video says 223,000 — and the company behind it, Anomaly, claims 16 million monthly developers. And the catch most reviews skip: you cannot log into OpenCode with a Claude Pro or Max subscription, because Anthropic closed that door earlier this year.
🧰 What a harness actually is 1:08
The definition is the right one: a harness is everything wrapped around the model — the system prompt, the tools, the permission model, how old context gets compacted, the subagents. It sits one layer above the model, which is why OpenCode ships no model of its own and instead plugs into 75+ providers through models.dev, or into a model on your own GPU.
The contrast: Claude Code is trained and built by the same company, which tunes harness and model together. The video's sharpest observation is that the 2.0 announcement itself admits the layer was never settled — Anomaly wrote that the old API "grew haphazardly while everyone was still figuring out what agents should even be", and then, in their words, that it was bad, so they threw it out and started over. He adds that another lab rebuilt its agent framework four times, and concludes: whatever you build on top of a harness might move.
🕳 The install trap 2:20
Version 1 and version 2 coexist badly, and the package names do not help. The video's warning is that the old npm package installs version 1 rather than 2. The official docs confirm the shape of the trap even more clearly than he does:
| Route | What you get |
|---|---|
npm install -g opencode-ai | Version 1 — the npm registry still shows opencode-ai at 1.19.5 |
brew install anomalyco/tap/opencode | Version 1 (the project's own tap) |
brew install opencode | Version 2 (Homebrew's core formula) |
paru -S opencode-bin (AUR) | Version 1 |
sudo pacman -S opencode | Version 2 (the official Arch package) |
winget install --id Anomaly.OpenCode | Version 2, with Anomaly.OpenCode.Desktop for the desktop app |
The docs add a detail worth knowing before you migrate: v1 and v2 use the same opencode command and cannot be installed side by side under their default command names. Version 1 → 2 also requires being on the latest 1.x first, then running the major-version upgrade. His cadence note is the reassuring part: roughly a dozen releases in the seventeen days since launch, so whatever version you see is probably newer than the one in the video.
⚙️ Three settings before you run anything 3:21
These are the most valuable three minutes of the video, and they are all in the migration guide rather than the marketing:
- External directory permission. Version 1 asked before touching files outside your project folder; version 2 allows it by default, which means the agent can read and write anywhere on your machine without asking. He cites a report that a later build removed the "ask" rule without a note in the release notes, and a user whose agent committed code into a different repository. The fix is one rule, placed last, because 2.0 evaluates permissions as an ordered list of action/resource/effect where the last matching rule wins.
- AGENTS.md, not CLAUDE.md. Version 2 reads
AGENTS.md; if your project instructions live inCLAUDE.md, OpenCode will not see them. Copy or link them, or the agent starts blind. - LSP config is accepted but not run. Version 2 will take your language-server configuration and then not start any language servers, so you get no diagnostics. The vendor's advice is to point the agent at your linter or type checker instead.
🏗 What 2.0 actually changed 4:39
Three structural changes, and only the third is genuinely unusual:
| Change | What it means |
|---|---|
| A background service | The server starts as one process on your machine; terminal, desktop and web are all clients. The session lives in the process, not the window — start a task in the terminal, close it, resume the same session in the desktop app, or pair another device. |
| Background work | The main agent can hand a job to a subagent — even on a different model — while you keep prompting; a long test suite can run async and ping the agent when it finishes. There is a keybind to shove a foreground task into the background. |
| Plugins everywhere | Anomaly built more than 80 of 2.0's own features as internal plugins and made them hot-reloadable — which means an agent can write a plugin mid-session and use it on the same turn. |
He is fair about the feature list: Claude Code already has subagents, background tasks and plugins, and "if you hide the logos, most coding agents taste the same". The real differences are who controls it and what it costs to run — which is the rest of the video.
🧮 Code mode, and the bloat it removes 6:23
The explanation of the problem is the clearest I have seen in a video: normally the model calls a tool, waits, gets the result pasted back into context, reads it, calls the next one — and every intermediate result rides along in the context for every turn after it. On top of that, every MCP server you connect injects its tool definitions into the prompt before you have typed anything.
Code mode flips that: OpenCode ships a small JavaScript interpreter that turns MCP servers and OpenAPI endpoints into plain functions, so instead of ten round trips the model writes one short script that finds the tools it needs, calls them, maps over results, and returns only the final value to the context. The idea has lineage — he credits Cloudflare for popularising the name last year — and in 2.0 every MCP server is in code mode by default.
The napkin math, and where it overreaches
Five MCP servers × 20 tools × ~500 tokens per tool schema = 50,000 tokens of definitions before the first prompt — a quarter of a 200K window. On Opus 5.5 at $4 per million input tokens that block costs about 20 cents uncached, and even at a 20-cent-per-million cache read it is a penny on every turn, multiplied by every turn of every session.
There is real evidence the bloat bites: denying the execute permission removes code mode and exposes MCP tools directly, and one GitHub issue shows that flipping it off mid-session re-sent 42,372 input tokens, uncached. But he then undermines his own framing in the honest direction: "With a handful of servers, the tool definitions usually aren't the bulk of your bill. The conversation is." The thousand-server pitch is not the realistic case.
⚖️ Same model, two harnesses 9:20
His methodological point is the one to keep: almost every OpenCode-versus-Claude-Code video puts OpenCode on a free model and Claude Code on Opus, which tests the harness and the model at once — two variables, one verdict. The only same-model measurement he could find was on OpenCode version 1, from July:
| Same model, two harnesses (reported) | Claude Code | OpenCode |
|---|---|---|
| Tokens sent before the prompt was even read | ~33,000 | ~7,000 |
| Average input tokens on passing runs | ~268,000 | ~72,000 |
| One multi-step task | 121,000 | 132,000 |
He labels it correctly: a small sample, "a direction, not a verdict" — and the third row is the reason. The direction is corroborated by something stronger than any single comparison: harness choice alone moves benchmark scores. The Terminal-Bench 2 paper reports Claude Opus 4.5 at 52.1% inside Claude Code and 57.8% inside Terminus 2, with radically different token profiles (256.9M input tokens for Claude Code versus 3.9M for Terminus 2 on the same model).
💸 The bill is the real decider 10:50
This is the video's thesis, and it is right: cost efficiency and token efficiency are different things. A harness can use a quarter of the tokens for the same task and still lose on money if its tokens are billed at API rates while the other side's are subsidised.
His arithmetic, which is worth reproducing because it is the whole argument in one table. One solid Opus 5.5 session: 40 turns, ~60,000 average context, 90% of input cached, ~1,500 output tokens per turn.
| Line item | Volume | Price | Cost |
|---|---|---|---|
| Cached input | 2.16M tokens | $0.20 / M | ~$0.43 |
| Uncached input | 240,000 tokens | $4 / M | ~$0.96 |
| Output | 60,000 tokens | $20 / M | ~$1.20 |
| Per session, mostly cached | ~$2.59 | ||
| Per session if nothing caches | 2.4M input at $4 / M | ~$9.60 + output |
The conclusion: at roughly $2.59–$2.83 per session, the $200 Max plan pays for itself somewhere around 71–77 sessions a month — about three and a half sessions per working day. Plenty of heavy users run more, which means for them Claude Code's biggest advantage is not the harness at all. It is the subsidy.
🎁 Free models, and what they cost you 13:02
OpenCode's own commercial layer is worth understanding because it is what most people actually meet. Zen is pay-as-you-go at list prices plus a processing fee; Go is a subscription. The verified pricing, from the Go documentation:
| Plan | Price | What it includes |
|---|---|---|
| Go | $10/month | Lower-cost access to the model list; ~$15–$100 monthly limit per model |
| Go Plus | $40/month | Higher limits (typically 3× Go), single-member workspaces |
| Go Teams | $20/member/month | Per-member limits, $5/month above Go on every model |
Usage caps are 20% of the monthly limit per 5 hours, 50% per week, 100% per month — the video's "you can't burn the whole month on a Tuesday". The model list runs to roughly thirty, including Claude Haiku 5.5 and DeepSeek V4.1 Flash, and his estimate of about 3,850 Haiku 5.5 requests per five hours on the $10 plan matches the vendor's own published estimate exactly.
The free tier has a data story that is worth the two minutes he spends on it: the DeepSeek and GLM free models come from providers with zero retention and no training; Beam Free does not train but retains for 30 days; Big Pickle, MiMo, Flint and the Nemotron models are explicitly described as collecting feedback and improving the model during the free period. He translates that correctly: your prompts are part of the deal. And the free tier now only works inside OpenCode's own apps — distribution, the same way the labs do it.
🖥 Local is not the cheap option 14:43
OpenCode 2 detects LM Studio and Ollama on its own, so the local route is one config away. His arithmetic for whether that is actually cheaper is the part most local-AI content skips:
- A 27B model (Qwen 3.8) at Q3_K_M is about 13 GB; on a 16 GB card that leaves roughly 3 GB for the KV cache — and agentic coding eats context fast, so context, not speed, is the binding constraint.
- On llama.cpp with less than 24 GB of VRAM the default context is only 4,096 tokens unless you raise it — and even raised, he cites a report of it dying at 32,768 tokens with a 262K limit configured.
- Assume 40 tokens/second and 250 W. A million output tokens is about 7 hours, ~1.7 kWh, so at ~23 cents/kWh you land near 40 cents per million output tokens — which barely beats the cheapest APIs before you count the card.
Conclusion, which is the correct one: local is the privacy and offline choice, not the cheap one. For a 27B model at this scale, the hosted free tiers and cheap API models are simply less expensive per token.
🔓 The breach, and the defaults around it 16:49
He does not skip it: on 17 October, OpenCode disclosed that attackers got into a legacy system that was being shut down, which stored third-party provider keys console users had added. About 1.4% of console users were affected and notified by email, and some received bills in the hundreds of dollars. The CLI itself was not touched — this is a hosted key-storage failure, not a compromised agent.
The advice is the right advice: if you ever pasted a provider key into that console, rotate it and set spend limits with the provider.
Then he turns to the defaults, which is where the real argument is:
- Hot-reloading plugins mean an agent can change its own guardrails mid-session. That is a genuine trade of flexibility for trust.
- No auto-mode classifier comparable to Claude Code's, as far as he can tell — so you either approve every command or let it run free. If you let it run free, put it in a container or VM.
- A sandboxed terminal may not be enough: a commenter found tool calls now run in the background server, outside that sandbox, with a standalone-mode flag as the suggested fix.
🧭 Verdict 18:26
| If you… | Then… | Because |
|---|---|---|
| Pay for ChatGPT Plus/Pro or Copilot, or run open-weight models | OpenCode makes a lot of sense | Those subscriptions are first-class in OpenCode; Claude's are not |
| Build automation on top of an SDK, or want a swappable model | OpenCode | One server, many clients, 75+ providers, local models, code mode |
| Are a heavy Opus user with a Claude subscription | Claude Code | The subsidy is the product: ~71–77 sessions a month on Max before API pricing is cheaper |
| Depend on LSP diagnostics or v1 plugins | Wait | No language servers run in 2.0; the plugin surface changed |
| Run agents unattended on your own machine | Neither, until you fix permissions | External-directory access is allowed by default; no auto-mode classifier; background tool calls escape terminal sandboxes |
The closing framing is the best line in the video: the harness is being squeezed from both sides — the labs are moving up into the harness and fencing off their subsidies, while the harness makers move down into inference with Zen, Go and free models. The harness was supposed to be the thin layer in the middle, and it is now the layer everyone is fighting over.
✅ Claims checked
| Claim in the video | Verdict | Evidence |
|---|---|---|
| OpenCode 2.0 shipped 12 October 2026; Anomaly is the company | Verified | Release coverage; opencode.ai docs and changelog both branded Anomaly |
| 223,000 GitHub stars | Verified | anomalyco/opencode: 223,260 stars, MIT licence |
| 16 million monthly developers | Company-reported | Anomaly's own figure; no independent source |
| The old npm package installs version 1, not 2 | Verified, and worse | npm opencode-ai is at 1.19.5; docs show Homebrew tap = v1 vs core formula = v2, AUR = v1 vs pacman = v2, winget ids = v2 |
| v1 and v2 cannot be installed side by side | Verified | Docs note both use the opencode command by default |
| External directory permission is allowed by default in v2 | Verified as the migration-guide default | Described in v2's migration guidance; permissions are an ordered list where the last match wins |
| v2 reads AGENTS.md, not CLAUDE.md | Verified | Docs: /init creates AGENTS.md; rules live in the Rules docs |
| v2 accepts LSP config but runs no language servers | Vendor-stated | Consistent with the v2 docs listing LSP servers separately from diagnostics; the "no diagnostics" outcome is the vendor's own advice to use a linter instead |
| Background service, clients, session survives closing the terminal | Verified | v2 docs: CLI, web, desktop and SDK all talk to one server |
| Code mode: MCP servers become functions in a JS interpreter, on by default | Verified as described | Cloudflare popularised the pattern; OpenCode ships a code-mode package and the execute permission gates it |
| Same-model comparison: 33k vs 7k pre-prompt tokens; 268k vs 72k input on passing runs; one task 121k vs 132k | Third-party, v1, small sample | Systemma, July 2026, OpenCode v1 — the video labels the limits itself |
| Same Opus 4.6 scores 58% in Claude Code vs 74.7% in "Terminus Kira" | Unverified | Published Terminal-Bench 2 numbers for Opus 4.5 are 52.1% (Claude Code) vs 57.8% (Terminus 2); the harness-swing claim holds, the specific figures do not check out here |
| Anthropic blocks subscription login from third-party harnesses | Verified behaviour | Neither the OpenCode docs nor the video's own setup path offers Claude subscription login |
| Go subscription: $10 / $40 / $20 per member | Verified | Go docs: Go $10, Go Plus $40, Go Teams $20/member |
| Usage caps of 20% per 5 hours, 50% weekly | Verified | Go docs: 5-hour 20%, weekly 50%, monthly 100% |
| ~3,850 Haiku 5.5 requests per 5 hours on the $10 plan | Verified exactly | Go docs' own estimate table: Claude Haiku 5.5 — 3,850 per 5 hours |
| ~30 models on Go, including Claude Haiku 5.5 and DeepSeek V4.1 Flash | Verified | Go model list (~28 entries) |
| Free models differ in data policy: zero-retention vs training/feedback | Verified in structure | Go docs list free models with regional/retention caveats; per-model terms match the video's three tiers |
| Zen charges list price plus a processing fee | Reported | Consistent with Zen docs; the 4.6% + $0.31 figures were not independently confirmed here |
| Local: 27B at ~13 GB leaves ~3 GB for KV cache; llama.cpp defaults to 4,096 context under 24 GB; ~40¢ per million output tokens in electricity | Reported arithmetic | Sound order-of-magnitude maths; power draw and rate are assumptions, and the 4,096 default is a llama.cpp behaviour, not an OpenCode one |
| Breach on 17 October: legacy system, provider keys, ~1.4% of console users, CLI untouched | Verified | Matches earlier coverage of the same incident |
| No auto-mode classifier in OpenCode; background tool calls can escape a terminal sandbox | Creator's assessment | Plausible from the permissions model; the sandbox-escape report is a user comment, not a CVE |
Transcript notes. The auto-captions mangle product names, corrected here against the docs: "Anomaly" is correct, "open code 2.0 / OpenCode" is correct, "opencode/ly" is a garbled package name (the docs' install paths are the reliable source), "Clawude MD" → CLAUDE.md, "Quen 3.8" → Qwen 3.8, "Myo v2.6" → MiMo V2.6, "Neatron" → Nemotron, "RTX 480 Super" → almost certainly the RTX 4080 Super, "C2L plus b" → the Ctrl/⌘+B background keybind, and "dash standalone flag" is an unidentifiable flag worth checking in your own build before relying on it.
🔑 Key takeaways
- Two questions, not one: is the harness better, and is the bill better. For a Claude subscriber the answers point in opposite directions, and the second one usually wins.
- Token efficiency is not cost efficiency. A harness can use a quarter of the tokens and still cost more, if its tokens are billed at API rates while the other side's are subsidised.
- The subscription lockout is the whole story. Claude models inside OpenCode are API-priced; a $200 Max plan pays for itself at roughly 71–77 Opus sessions a month, which is where Claude Code's real advantage lives.
- Fix three settings first: restore "ask" for external directories (last rule wins), move instructions into
AGENTS.md, and point the agent at a linter because no language servers run. - Code mode attacks a real problem — 50,000 tokens of MCP tool definitions before your first prompt — but with five servers the conversation, not the schemas, is what you are paying for.
- The harness alone moves benchmark scores by double digits (52.1% vs 57.8% for the same Opus 4.5 in two harnesses). The video's 58 vs 74.7 figures are unverified; the effect is not.
- OpenCode 2 is a general-purpose unattended agent by default: background service, hot-reloadable plugins an agent can write for itself, no auto-mode classifier, external writes allowed. Container or VM, not laptop.
- Free models are a data trade. Zero-retention on some, training/feedback on others, and the free tier only inside OpenCode's own apps — a distribution play, not charity.
- Local is privacy, not savings. A 27B model on a 16 GB card is context-limited before it is speed-limited, and electricity alone lands near 40¢ per million output tokens before hardware.
- The harness is the contested layer: labs moving up into it and fencing subsidies, harness makers moving down into inference. Your workflow's portability depends on which side wins.
🔗 Resources & links
OpenCode
- anomalyco/opencode — MIT, 223k stars
- OpenCode 2 docs and the changelog; v1 docs remain at opencode.ai/docs
- OpenCode Go — plans, per-model limits, request estimates, validated harnesses
- Console models and Console overview (Zen)
Benchmarks and pricing used here
- Terminal-Bench 2 paper — per-model, per-harness resolution rates and token profiles (Claude Opus 4.5: 52.1% in Claude Code, 57.8% in Terminus 2)
- models.dev — the provider and model registry OpenCode reads