Claude Code burns 33k tokens before reading your prompt. OpenCode uses 7k.

A team switches from a self-hosted coding assistant to Claude Code mid-sprint, expecting the API costs to be roughly comparable. Two weeks later, the bill is nearly three times what they projected. Nothing about their prompts changed. The model is the same. What they did not account for was how many tokens Claude Code was consuming before it ever read a single line of their actual request.

That is the finding at the center of a technical analysis published by Systima AI, which measured token overhead between Claude Code and OpenCode on identical tasks. The numbers are stark: Claude Code sends approximately 33,000 tokens before processing your prompt. OpenCode sends around 7,000. That gap does not come from differences in model capability or output quality. It comes from how each tool structures what it sends to the model before your words arrive.

A concrete scenario: a mid-size team running Claude Code at scale

Consider a team of six developers, each making around 80 API calls per day through Claude Code. That is a realistic number for an active coding assistant workflow: debugging sessions, code review, refactoring requests, test generation. Nothing exotic.

At 33,000 tokens of overhead per call, each call burns through that baseline before the model sees the actual task. For a prompt that itself runs 2,000 tokens, the overhead is roughly 94% of the total input token count. The model spends the vast majority of its attention budget on scaffold, not on your code.

Now price that out. Claude Sonnet 5 costs $3.00 per million input tokens. Each call at 33k overhead tokens costs about $0.10 in overhead alone, before any output. At 80 calls per developer per day and six developers, that is $48 per day in pure overhead. Over a 30-day month, that is $1,440 that purchased nothing: no analysis, no generated code, no test output. Just the cost of Claude Code loading its context before it started listening.

OpenCode's 7,000-token overhead changes the math considerably. The same team, same call volume, same model: about $10 per day in overhead, or $300 per month. The delta between the two tools, for the same workflow on the same model, is roughly $1,100 per month in this scenario.

What token overhead is and why it accumulates so fast

The analogy that makes this concrete: imagine every time you asked a colleague a question, they first read aloud the entire employee handbook before responding. The handbook is not irrelevant, exactly. It contains useful context. But if your question was "what's the variable name for the auth token in this file," you did not need 200 pages of policy before the answer.

Token overhead in AI coding tools works the same way. When a tool like Claude Code sends a request to the underlying model, it does not send just your message. It constructs a full context package: system prompts, tool definitions, available function schemas, instructions about how to handle different file types, rules about how to structure responses, safety guidelines, capability declarations. All of that scaffolding has to be tokenized and sent with every single request.

The 33,000 figure for Claude Code is not a bug. It reflects deliberate design choices: Claude Code exposes a broad set of tools and capabilities to the model, and the model needs to know what those tools are and how to use them. Every tool definition costs tokens. A tool that can read files, write files, run shell commands, search codebases, and manage git operations needs to explain all of that to the model on every call, because the model has no persistent memory between calls.

OpenCode's 7,000-token overhead suggests a different philosophy: expose fewer capabilities per call, or describe them more concisely. Whether that results in meaningfully different behavior on real tasks is a separate question from the cost difference.

The counterargument: overhead is not waste

The framing of "wasted tokens" is worth challenging directly. Those 33,000 tokens are not random padding. They encode Claude Code's understanding of its own capabilities, constraints, and operational context. Strip them out, and you do not get a cheaper version of the same tool. You get a different tool that can do less.

The tool definitions that inflate Claude Code's overhead are also what let it do things OpenCode cannot, or cannot do as reliably. If Claude Code can handle more complex multi-step tasks, manage larger codebase contexts, or produce fewer hallucinated API calls because it has richer tool schema in its context, then the overhead is purchasing something real. You are paying for a more capable agentic substrate, not for inefficiency.

There is also the question of what you measure. Token overhead per call is easy to count. Developer hours saved per week is harder. If Claude Code's richer context means developers resolve issues in two interactions instead of five, the overhead per successful resolution might be lower than the raw per-call numbers suggest. A tool that costs more per call but requires fewer calls to complete a task can be cheaper in total. The Systima analysis does not measure that, and it is a real gap in the comparison.

OpenCode is also a newer, less battle-tested tool. Lower overhead may partly reflect fewer edge cases handled, less defensive tooling, or simpler capability sets. The 26,000-token gap between the two tools might shrink as OpenCode matures and adds features. At that point, the cost comparison looks different.

From the Hacker News thread

"The real question is whether the extra capability surface that Claude Code's overhead buys you actually gets used on a typical call. In my experience, it does not. Most calls are 'explain this function' or 'write a test for this method.' You do not need 33k tokens of preamble for that." - Hacker News commenter on the Systima analysis

This gets at something important. Claude Code is designed as a general-purpose agentic coding tool. OpenCode may be optimized for a narrower set of common tasks. The token overhead reflects the capability envelope each tool tries to give the model. If your workflow rarely touches the outer edge of that envelope, you are paying for surface area you do not use.

The practical split this suggests: teams running high-volume, relatively routine coding assistant tasks, code explanation, unit test generation, small refactors, are the ones most exposed to the overhead cost. Teams running complex multi-file agentic workflows where Claude Code's full capability set is regularly exercised are the ones most likely to find the overhead justified. Neither group is wrong. They are just running different workloads. See how different coding tools compare on similar dimensions if you are still orienting toward the right tool for your team's specific patterns.

For a broader look at how these tools perform at the model level, the running SOTA models locally guide covers some of the architectural tradeoffs that affect token behavior in local versus API-hosted configurations.

What will clarify this debate is empirical data on task completion rates and total call counts per workflow, not just per-call overhead. The Systima analysis surfaces a real and measurable cost difference. It does not settle whether that cost difference corresponds to a value difference. If either OpenCode or a third competitor publishes task-completion benchmarks alongside token counts in the next six months, the "overhead as capability tax" argument will either hold up or collapse under the weight of actual output data. That is the measurement the field currently lacks, and it will arrive before the end of 2026.