Systima's empirical study, done by proxying both CLIs through their own logger, found Claude Code sends ~33k tokens on a cold turn versus OpenCode's ~7k on the same Sonnet model. Because agentic CLIs re-send full context on every turn due to the stateless API, they argue this 26k-token gap compounds to ~520k tokens of pure overhead over a 20-turn session — a concrete, reproducible cost users are paying.
The editorial argues the 33k tokens aren't wasted — they encode a much larger tool surface (Bash with safety preamble, rich Edit with matching rules, TodoWrite, Task/Agent, WebSearch, WebFetch, notebook editing) plus detailed usage instructions. Anthropic has optimized Claude Code for capability breadth and for teaching the model how to use those tools reliably, which is a defensible design choice even if it costs tokens.
Systima, a small team that mostly uses OpenCode but was briefly forced onto Claude Code during a Meridian outage, noticed their Anthropic usage meter climbing at what looked like a much faster clip than usual. They did the sensible thing: they proxied both CLIs through their own logger and captured every request going to Anthropic's endpoint on identical tasks.
The numbers are hard to argue with. On a cold turn — the first message of a session, before any tool calls, before any file reads, before the model has even seen what you want — Claude Code sends roughly 33,000 input tokens. OpenCode, running the same underlying Sonnet model, sends roughly 7,000. That's a ~26k-token gap, and it lives almost entirely in the system prompt and tool schema block that ships on every single request.
The reason it compounds is architectural. Agentic coding CLIs don't stream a conversation the way a chat UI does; they re-send the full context (system prompt + tool schemas + conversation history + tool results) on every turn because the API is stateless. So the 26k-token overhead isn't paid once per session — it's paid once per turn, and a real coding session is 10 to 50 turns. A back-of-envelope: a 20-turn session with Claude Code eats ~520k tokens of pure overhead before counting your actual code, diffs, or model outputs. OpenCode's overhead over the same 20 turns is ~140k.
The obvious reading is "Claude Code is bloated," and that's partly true, but it undersells what's actually in those 33k tokens. Claude Code ships a much larger tool surface out of the box — a full-featured Bash tool with a long safety preamble, a rich Edit tool with detailed matching rules, TodoWrite, Task/Agent, WebSearch, WebFetch, notebook editing, and so on. Each tool description is a few hundred to a few thousand tokens of natural-language spec. Anthropic has clearly optimized Claude Code for capability breadth and for teaching the model *how* to use the tools well, not for token minimalism.
OpenCode makes the opposite trade. It ships a smaller, thinner tool set with terser descriptions, delegates more to the model's own judgment, and keeps the system prompt lean. On simple tasks — edit this file, run these tests, fix this bug — the extra scaffolding in Claude Code is mostly dead weight the model routes around. On complex tasks — long multi-file refactors, sub-agent delegation, careful ambiguous edits — the extra scaffolding is doing real work. Neither posture is wrong. They're aimed at different price points.
The pricing math is where this stops being academic. At Anthropic's list Sonnet input price of $3/M tokens, that 26k-per-turn delta is roughly $0.08 per turn, or $1.60 across a 20-turn session — per developer, per session, before you count anything you actually asked for. On a team of 10 engineers doing 5 sessions a day, that's ~$80/day, ~$1,700/month, purely in overhead bytes. Prompt caching softens this considerably — the system prompt and tool schemas are the ideal cache target, and Anthropic's cache read pricing is 10% of write — but caching only helps if your wrapper is actually stamping cache breakpoints correctly and your turns fall inside the 5-minute TTL. Long think-then-run cycles routinely blow past that window.
The subscription users have a different but related problem. Claude Code Max at $200/month meters against a token budget, not a request budget, and the community threads on Reddit and HN over the last few months have been full of people hitting weekly caps faster than they expected. If your bytes-per-turn are 5x higher than the tool next door, your "unlimited" plan runs out 5x sooner in the ways that count. The Systima writeup gives that anecdotal frustration an actual number to point at.
The HN thread (544 points, one of the top stories of the week) landed hard for a reason. It confirms something a lot of Claude Code users had suspected but couldn't quantify: the meter isn't just moving because you're doing more — the wrapper itself is heavier. A few commenters pushed back on the methodology (was the tool set fair? was the same model version pinned? was caching disabled symmetrically?), and those are legitimate questions, but nobody produced numbers that closed the gap meaningfully. The 5x ratio is real even if the exact 33k vs. 7k figures move around at the edges.
If you're paying per token, the cheapest optimization you can make this week is switching the wrapper, not the model. Same Sonnet under the hood, ~5x cheaper input side. OpenCode, Aider, and the growing crop of leaner CLIs are all viable — pick whichever matches your workflow. The tradeoff is real: you'll lose some of Claude Code's polished sub-agent orchestration, the built-in Task tool, and the tighter tool descriptions that help the model recover from mistakes. On simple, well-scoped work you won't notice. On long autonomous runs you might.
If you're on Max and hitting caps, audit your session shape before you switch tools. A lot of the token bleed isn't the system prompt — it's re-reading the same files, running redundant greps, or letting the model wander through a big repo with no scoping. Even inside Claude Code, aggressive use of `--resume`, tighter file context, and explicit `/clear` between unrelated tasks can cut your effective per-task token count more than switching wrappers would.
If you're building an agent framework of your own, the takeaway is uglier: tool schema weight is a real cost center and almost no one is measuring it. Every tool you add has a fixed per-turn tax. The Systima data implies that Anthropic's own team ships something in the 25-30k range of tools + preamble, and they had every reason to keep it lean. Yours is probably worse. Prompt caching is table stakes, and if you're not stamping `cache_control` breakpoints on your system prompt and tool block, you are lighting money on fire on every turn.
Anthropic will almost certainly respond to this — either by trimming Claude Code's default system prompt, by shipping a "lean mode" flag, or by leaning harder on caching so the sticker-price comparison stops being embarrassing. The interesting second-order question is whether the tool schema itself becomes a versioned, cacheable artifact the model can reference by ID instead of by full re-transmission. That's the only path to closing this gap without giving up capability, and it's a natural next step for the Messages API. In the meantime, the practitioner move is boring and obvious: measure your own wrapper's overhead, and if it's north of 10k tokens per turn, you have a line item worth cutting.
This started based off of a hunch. We usually use OpenCode, but were 'forced' to use Claude Code for a while due to issues with Meridian. In that time, we saw the usage meter rise much, much
→ read on Hacker NewsMy opinion is that claude code uses more tokens simply because Anthropic makes more money that way and forces people into their subscriptions. This is supported by the fact that they won't let you use your sub on a different coding agent. I use pi btw.
UPDATE:After reading PUSH_AX's valid comment: ``` This is like saying contractor (A) asked for $33,000 to undertake the work and contractor (B) asked for $7,000 Are we measuring and caring about the right thing? ``` We will update the post to include:1) A more in-depth task. 2) Qualitative resu
This isn’t limited to large system prompts. Coding-agent harnesses are also becoming more aggressive about using tools, even for trivial requests. In our tests, prompts such as “Hey” or “commit” sometimes triggered 30+ tool calls:https://quesma.com/blog/the-true-cost-of-saying-hi
And pi agent is even less.The entire agent system prompt can be seen here:https://github.com/earendil-works/pi/blob/main/packages%2Fco...
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.
What really burns tokens is sub agents. I once gave Claude Code a pretty big task, and it immediately launched 7 sub agents which burned through my budget before even one of them was finished. Tried again 5 hours later: same result.If I let the main agent do the same task sequentially, it was no pro