Claude Code's Reported 33,000-Token Overhead and What It Costs

A simple request to an AI coding assistant can carry thousands of tokens that have nothing to do with the task itself. In an analysis discussed on July 12 and covered here as of July 13, 2026, Systima measured approximately 33,000 tokens of baseline scaffolding in Claude Code, compared with roughly 7,000 in OpenCode using the same model.

That is a reported 4.7x difference before adding the user's prompt. The scaffolding includes system instructions and descriptions of the tools the model can call. It travels with the API request even when the task needs very little of that machinery.

The amount billed depends on caching and the rates applied to each token category. Still, the measurements show why a short prompt can produce a much larger usage report than its length suggests.

Where the baseline tokens come from

Systima placed a logging proxy between each coding tool's harness and Anthropic's API endpoint. The proxy, about 200 lines of Node, captured the JSON request payloads, including system blocks, tool schemas, and usage metrics. The full analysis compares both the starting overhead and behavior during longer tasks.

Claude Code sent 27 tool descriptions with each cold request. OpenCode sent 10. A tool schema tells the model what a tool does and what arguments it accepts, so these descriptions consume input tokens even before a tool is used.

Both tools answered the minimal test with “OK.” The task deliberately required almost no work, making the baseline easier to isolate.

Claude Code's larger toolset supports background agents, skill delegation, and multi-step orchestration. Those capabilities require descriptions and instructions. The measured difference therefore reflects a design choice, rather than simply an unusually wordy user request.

Cache behavior changes the bill

A large request prefix doesn't necessarily cost the same amount every time. Anthropic's prompt cache charges a premium to write tokens into the cache, then a lower rate to read cached tokens on later requests. Stable prefixes can make repeated scaffolding much cheaper.

Systima reported byte-identical OpenCode request prefixes across its test sessions. In a repeated file-summarization loop, OpenCode required only 1,003 cache-write tokens. That stability made its cache behavior relatively predictable.

Claude Code produced three distinct request classes per session, with different system bytes. One multi-step task recorded 53,839 cache tokens written, including a complete mid-task rewrite. Across equivalent tasks, its cache-write totals were 5.9x to 54x higher than OpenCode's.

The analysis attributes this behavior to Claude Code changing its context as it selects an orchestration path. When a prefix changes, the affected content may need to be written into the cache again rather than read at the cheaper rate. A budget based only on a warm-cache request can therefore miss a substantial part of the cost.

This is a separate issue from the initial 33,000-token measurement. One concerns how much scaffolding the tool sends; the other concerns how reliably that scaffolding can be reused at cached-input rates.

Instruction files, MCP servers, and subagents add more

The baseline tests used factory configurations, without MCP servers or instruction files. Systima also tested configurations with project instructions and external tools connected through MCP, the Model Context Protocol.

• A 72KB CLAUDE.md instruction file added roughly 20,000 tokens per request to both tools.
• Five MCP servers added between 4,900 and 6,967 tokens, depending on their schemas.
• Subagent delegation increased one task from 121,000 tokens to 513,000 tokens because each subagent required its own startup context.

The subagent example represents a 4.2x increase. Delegation can make a workflow easier to organize, but a background agent still needs enough instructions and context to do its job. Those startup costs can be repeated as work is split among agents.

The analysis also reported a working configuration in which OpenCode, with 11 MCP servers, required 90,817 cold-cache tokens before adding the user's task. Claude Code, with four servers, required approximately 75,000 tokens.

The reported comparison describes both configurations as roughly 12x their respective baselines and argues that instruction files and MCP tools can dominate the initial overhead. These weren't matching server configurations, however, so the totals don't isolate the cost of the coding harness alone.

The concern with deeper delegation is that each additional agent can bring another startup cost. A three-level workflow could become expensive even if its top-level task looks straightforward. Treating the observed 4.2x increase as a fixed multiplier at every nesting level would be an extrapolation from the reported example, rather than a separate measurement.

What the correctness tests showed

Higher overhead could be worthwhile if it consistently bought better results. In Systima's reported ten-lane benchmark, independent verification found that both tools passed five of five test suites. Average metered usage was 268,000 tokens for Claude Code and 72,000 for OpenCode, a 3.7x difference with the same verified correctness in those tests.

A more complex write-run-test-fix task initially looked better for Claude Code. Parallel tool batching helped it finish at 121,000 tokens, compared with OpenCode's 132,000.

When retested on newer models, Claude Code required twice as many requests and used 298,000 tokens against OpenCode's 133,000, a roughly 2.2x difference. The changed result also shows why one task or model configuration isn't enough to establish a general efficiency ranking.

These tests didn't demonstrate a correctness benefit that offset Claude Code's extra token use. They also don't establish that the two tools will perform equally on every workload. Claude Code's orchestration features may still be valuable for tasks that depend on background work, delegation, or parallel execution.

A team-scale cost estimate

Consider a planning scenario with 30 engineers, each running 15 substantive AI coding sessions per day. Starting from a Claude Code cold-cache configuration of about 75,000 tokens, assume an average of 50,000 overhead tokens per task after cache effects.

That assumption produces 450 daily sessions and 22.5 million overhead tokens per day, before counting task-specific code or output. Using the cited approximate input rate of $3 per million tokens for claude-sonnet-5, the calculation comes to $67.50 per day, or roughly $24,000 per year.

This is a planning estimate, not a measured team bill. It depends on the assumed average overhead, the applicable model price, the mix of cache writes and reads, and how many days the team runs at that usage level. Tokens reported as input, cache writes, and cache reads shouldn't automatically be priced as if they were interchangeable.

Applying a threefold to fourfold overhead reduction would substantially lower that estimate. The baseline and benchmark results suggest that possibility for OpenCode, but the working-configuration measurements don't establish the same savings for every team. Large instruction files and extensive MCP setups can make either tool expensive.

Measure the configuration that will be used

For mostly simple tasks, such as summarizing a file, writing a test, or explaining an error, Claude Code's larger baseline means paying for tool descriptions that the task may never use. For workflows built around multi-agent orchestration, the additional capabilities may justify the premium. The decision depends on the features used, the quality of the result, and the measured request cost.

A useful evaluation should separate cold-cache startup, warm-cache reuse, cache rewrites, and subagent startup. It should also include the actual instruction files and MCP servers used by the team. A clean factory configuration answers a narrower question than a production workflow.

Systima released its approximately 200-line Node logging proxy on GitHub, making the measurement approach available for testing other configurations. The Hacker News discussion that surfaced the analysis on July 12 covered its architectural implications, and Gigazine's coverage provides a shorter account of the token breakdown.

The most useful number for a deployment is the cost of its own completed tasks, with scaffolding and cache behavior included. Prompt length alone leaves too much of that cost out.