2026-07-13

Claude Code’s Hidden Token Tax Is Bigger Than It Looks

If you build with Claude Code, this article is a useful reality check: the agent you think you’re calling is not just your prompt plus a model. It’s a whole bundle of system instructions, tool schemas, reminders, cache behavior, and sometimes subagents, all of which can eat into your context and your bill before the actual job even starts.

Key Points

The authors measured Claude Code and OpenCode at the API boundary using a logging proxy, so they could see the exact payloads sent and the usage returned by the model endpoint.
On a trivial “reply with exactly OK” task, Claude Code sent roughly 33,000 tokens of system prompt, tool schemas, and scaffolding before the user prompt; OpenCode sent about 7,000.
Claude Code’s first-turn payload was dominated by tool definitions: about 24,000 of its ~33,000 tokens, versus roughly 4,800 of OpenCode’s ~6,900.
Even with tools disabled, Claude Code’s system prompt was still more than three times larger than OpenCode’s.
On a simple file-summary task, Claude Code used 6 HTTP requests and about 199,000 cumulative metered input tokens; OpenCode used 4 requests and about 41,000, plus one Haiku side call for session titling.
On a multi-step write-run-test-fix loop, the gap narrowed. Claude Code batched work into fewer requests and ended around 121,000 tokens, while OpenCode, with one tool call per turn, landed around 132,000 tokens.
Claude Code’s baseline is expensive, but batching can make it competitive or even cheaper on multi-step tasks because OpenCode repays its smaller baseline every turn.
The article says Claude Code’s prompt shape is model-dependent: on Claude Fable 5, the baseline shrank compared with Sonnet, and the multi-step outcome changed too.
Caching matters, but not in a magical way. OpenCode’s prefix stayed byte-identical across runs and could be cached once per session, while Claude Code rewrote tens of thousands of cache tokens mid-session in some runs.
Adding a real repo’s instruction file can be costly: a 72KB AGENTS.md or CLAUDE.md file added about 20,000 tokens per request.
Five modest MCP servers added another 5,000 to 7,000 tokens.
In the article’s “real working setup” framing, Claude Code could be 75,000 to 85,000 tokens deep before the user even typed anything.
Subagents multiply overhead hard: a task that cost 121,000 tokens directly cost 513,000 tokens when split across two subagents.
The quality section is important because it keeps this from becoming a pure cost rant: the authors also checked pass rates against a seeded, hash-verified test suite.

My Take

What strikes me is that this is not really a “Claude Code is bad” story. It’s a reminder that agent frameworks are infrastructure, and infrastructure has overhead. The annoying part is that most of that overhead is invisible until you measure at the wire, which is exactly why this kind of post is valuable.

I think the most interesting result is the one that cuts against the obvious take: Claude Code can lose badly on the first turn and still win overall on a longer task because it batches tool use more aggressively. That’s the part people miss when they fixate on prompt size alone. A bigger baseline is ugly, yes, but if it reduces turn count enough, the total can come back down.

What worries me is the subagent multiplier. That 121,000-to-513,000 jump is the sort of thing that can quietly wreck a production budget if you let the system fan out too freely. I’d be curious whether teams using Claude Code in anger are already hitting this and just haven’t looked closely enough at their usage traces.

The cache story is also more mixed than the usual “prompt caching will save you” pitch. Caching helps, but it does not erase the fact that you still pay to send and reread a giant scaffold, and Claude Code appears to rewrite cache state more often than you’d hope. That feels like the least glamorous but most operationally relevant finding here.

If I were using Claude Code, I’d actually do two things from this article. First, I’d measure my own sessions the way Systima did, because the defaults are clearly not cheap. Second, I’d be ruthless about MCP servers, instruction files, and subagent fan-out. Not because they’re bad, but because they’re exactly where the hidden tax lives.

The takeaway is simple: Claude Code is powerful, but it’s not a lightweight wrapper around the model. If you care about cost, latency, or auditability, you need to treat its prompt budget as part of the product surface, not a backend detail.