Token overhead comparison between Claude Code and OpenCode

Systima.ai dropped a measurement study on Hacker News last week that hit a nerve. They put a logging proxy between two coding agents and Anthropic's API, captured every byte each harness sent, and found that Claude Code ships roughly 33,000 tokens of system prompt, tool schemas, and injected scaffolding before your prompt even arrives. OpenCode ships about 7,000. Same model, same machine, same tasks. A 4.7x difference that shows up on every single request.

The thread ballooned to 564 points and 315 comments. The debate wasn't whether the numbers were real. It was whether the extra context buys better outcomes, or whether Anthropic's harness is just bloated by design.

The anatomy of 33,000 tokens

Break down where those tokens go and the picture gets uncomfortable. Claude Code carries 27 tool definitions that consume about 24,000 tokens of schema. OpenCode has 10 tools at roughly 4,800. But tool count alone doesn't explain it. Claude Code also injects three <system-reminder> blocks before your prompt: a catalogue of agent types for delegation, a catalogue of available skills, and user context. OpenCode carries none of that scaffolding.

Strip the tools entirely and the raw system prompt tells its own story. Claude Code's behavioural doctrine, tone rules, safety guidance, and task-management instructions weigh in at about 6,500 tokens. OpenCode's: roughly 2,000. Even with zero tools attached, Claude Code is three times heavier.

One commenter on HN pointed out that "pi" (an open-source coding agent) sends less than 1,000 tokens for its entire system prompt. The spectrum covers pi at 1k, OpenCode at 7k, and Claude Code at 33k, and none of these agents are doing actually different things.

Where the real money goes

The fixed overhead is bad enough. What multiplies the bill is caching behaviour. OpenCode's request prefix is byte-identical across every run. The same system prompt, the same tool schemas, same bytes every time. This means API caching works exactly as designed: pay the write premium once, read it back at a tenth of the price for the rest of the session.

Claude Code rewrites its cache mid-session. On an identical file-summarise task, Claude Code wrote 53,839 cache tokens across five requests, including a complete mid-task rewrite of its full prefix. OpenCode wrote 1,003. The researchers re-ran the task to confirm it wasn't a fluke. It reproduced: 43,342 tokens in the first run, 36,899 in the second.

Cache writes bill at a premium, 1.25x for the five-minute tier, 2x for the one-hour tier. This is why one usage dashboard climbs while the other stays flat. It's not that Claude Code uses more tokens on the task itself. It's that the harness keeps invalidating its own cache.

A user named slopinthebag summed it up in the HN thread: "Anthropic wants to produce the best coding agent possible and doesn't care, or is even incentivized, about high costs. Other harnesses have to make trade-offs between performance and cost." The observation is hard to argue with when the numbers are this lopsided.

The subagent trap

If you think the baseline is expensive, wait until you fan work out to subagents. Systima asked each harness to delegate to two parallel subagents for a small task. Claude Code completed it with 9 model requests across three distinct request classes. Cumulative metered input: 513,000 tokens. The same task done directly: 121,000. A 4.2x multiplier, because every subagent pays its own bootstrap and the parent swallows its transcript.

OpenCode's subagent design is leaner. Its subagent requests carry a reduced profile: a 1,379-character system prompt and 5 tools, compared to Claude Code's 3,554-character agent prompt and 24 tools. The researchers didn't get clean totals through their gateway for OpenCode's subagent lane, but the payload difference is stark.

This matters because subagent delegation is becoming the default pattern for anything non-trivial. If your heavy sessions keep surprising you on the bill, the first place to look is whether every task actually needs a fan-out, or whether the harness is just doing what it's optimised to do.

The counterintuitive part

Here's the wrinkle that kept the HN thread interesting. On a multi-step coding task, a write-run-test-fix loop, Claude Code's whole-task total came out lower than OpenCode's. The reason: Claude Code batches tool calls into fewer requests. Three HTTP requests for Claude Code versus nine for OpenCode on the same task. Because the baseline is re-sent on every request, request count multiplies baseline. OpenCode paid its 7k baseline nine times. Claude Code paid its 33k three times. The totals converged.

The lesson isn't "use Claude Code." It's that token efficiency isn't just about the starting payload. It's about how the session unfolds. A large-baseline harness that batches aggressively and a small-baseline harness that serialises can end up in the same place. Task structure determines final expenditure, not starting conditions.

What this means for production setups

The multipliers stack. A real 72KB instruction file adds about 20,000 tokens per request to both harnesses. Five MCP servers add 5,000 to 7,000. A production Claude Code setup with instruction files, MCP servers, and plugins can hit 75,000 to 85,000 tokens before the user has typed a word. On a 200k context window, that's over 40% consumed by bootstrap alone, leaving less room for actual code before compaction kicks in and spends yet more tokens summarising.

The researchers recommend measuring what you actually send. "If you run agentic systems in production and cannot currently answer 'what exactly did we send to the model last Tuesday', that is the gap worth closing first," they wrote. The token accounting falls out of it for free.

They open-sourced the measurement rig, roughly 200 lines of Node that is a logging proxy between harness and model endpoint. Point your ANTHROPIC_BASE_URL at it, give the harness a fresh config directory, and watch the boundary. It's the kind of tool that should be standard practice but isn't.

Sources