A new token-overhead benchmark is spreading through developer circles because it puts hard numbers on a cost many teams only feel after the invoice lands: the coding-agent harness can spend a meaningful token budget before it even reads the user’s actual prompt.
The headline result from Systima’s July 12 benchmark is stark: Claude Code sent about 33,000 tokens before reading the prompt, while OpenCode sent about 7,000 in the measured out-of-the-box baseline. That is roughly a 4.7x gap at the first-request floor.
This is not an Anthropic API price change. Claude Sonnet 5 is still listed in our live data at $2.00 per million input tokens, $0.20 per million cached input tokens, and $10.00 per million output tokens during its introductory period. Claude Opus 4.8 is still listed at $5.00 input, $0.50 cached input, and $25.00 output per million tokens.
The pricing impact is about effective cost. If your coding agent quietly sends large system prompts, tool schemas, instruction files, subagent instructions, and repeated history on every request, the rate card understates what each accepted task really costs.
For live provider rates, compare Anthropic pricing, OpenAI pricing, and the full AI pricing table, then model your own sessions in the AI token calculator. For background on why repeated prompt prefixes matter, read our guide to cached tokens and AI cost savings.
What changed
The source material is Systima’s post, “Claude Code Sends 4.7x More Tokens Than OpenCode Before Reading Your Prompt”, surfaced by today’s HN AI Pricing alert.
Systima measured Claude Code and OpenCode at the API boundary, then added common real-world layers: instruction files, MCP servers, workflow templates, subagents, and cache behavior.
The most important reported numbers:
| Measurement | Claude Code | OpenCode | Pricing read |
|---|---|---|---|
| Baseline before prompt | ~33,000 tokens | ~7,000 tokens | Claude Code starts with a much larger floor |
| Large instruction file | +~20,000 tokens/request | +~20,000 tokens/request | Big repo instructions hurt both tools |
| Small MCP servers | +~1,000-1,400 tokens/server/request | Similar | Tool schemas become a recurring tax |
| Multi-step task total | ~121,000 metered input tokens | ~132,000 metered input tokens | Request count can offset baseline differences |
| Claude Code with two subagents | ~513,000 metered input tokens | Not cleanly quantified | Delegation can multiply cost fast |
| Real config example | ~75,000-token payload | 90,817 metered input tokens | User setup can dominate the harness floor |
The nuance matters. Claude Code’s baseline was much larger, but in one multi-step task it batched work into fewer model requests. OpenCode started leaner but made more turns, so cumulative input landed in the same broad range for that task.
That means the correct takeaway is not “Claude Code is always 4.7x the cost.” It is sharper: agent cost is baseline times request count, plus configuration weight, plus cache behavior, plus output.
Current pricing comparison
Here is what the reported baseline means at today’s tracked Claude API prices if those tokens are billed as fresh input.
| Model route | 33k input tokens | 7k input tokens | Difference per first request |
|---|---|---|---|
| Claude Sonnet 5 at $2/M input | $0.066 | $0.014 | $0.052 |
| Claude Opus 4.8 at $5/M input | $0.165 | $0.035 | $0.130 |
| Claude Haiku 4.5 at $1/M input | $0.033 | $0.007 | $0.026 |
Those numbers look small for one request. They stop looking small when multiplied by daily developer sessions, agent retries, CI tasks, and subagent fan-out.
For example, 1,000 cold starts at the reported 33k-token floor is 33 million input tokens before user intent, repository snippets, tool results, or output. On Sonnet 5, that is about $66 of fresh input. On Opus 4.8, it is about $165. The 7k-token floor would be about $14 on Sonnet 5 or $35 on Opus 4.8.
Prompt caching can reduce repeated-input cost dramatically, but it does not erase the operational problem. Cached input is cheaper in the public rate card, yet large prefixes still consume context window space, can require cache writes, and can miss cache if the harness changes the prefix between requests.
Why this matters for coding-agent buyers
Coding-agent cost is rarely dominated by a single user prompt. It comes from the scaffolding around the prompt:
- system instructions
- tool definitions
- MCP schemas
- repository instruction files
- file snippets
- prior tool results
- subagent prompts and summaries
- retries after failed edits or tests
Systima’s most useful contribution is separating these layers. A 72KB instruction file reportedly added just over 20,000 tokens per request to both harnesses. That means a detailed AGENTS.md or CLAUDE.md can be economically correct for quality, but it is not free. It rides on every request unless the tool handles it selectively.
MCP servers show the same pattern. The benchmark reports roughly 1,000 to 1,400 tokens per small public server per request. Five small servers added about 4,900 tokens to Claude Code by payload and 6,967 metered tokens to OpenCode. Production MCP servers with larger schemas can cost more.
Subagents are the bigger warning. In the reported Claude Code fan-out test, the same work that used about 121,000 metered input tokens directly reached about 513,000 input tokens with two subagents. That is a 4.2x multiplier in the captured run.
Delegation may still be worth it. A subagent that finds the bug faster can save human time and reduce failed retries. But teams should not turn on subagents and assume the model bill scales linearly.
What this means
For individual developers, the immediate lesson is to check the hidden setup cost of your favorite coding tool before blaming the model price alone. If a session starts with 75k to 90k tokens of harness and configuration, switching from Opus to Sonnet helps, but pruning tool schemas and instruction files may help more.
For engineering managers, the buying metric should be cost per accepted task, not cost per million tokens. A heavier agent can be cheaper if it finishes in fewer turns and passes tests more often. A leaner agent can be expensive if it makes many serial calls or needs repeated manual correction.
For tool builders, cache stability is now a product feature. Systima reports OpenCode emitted byte-identical prefixes across runs in its dataset, while Claude Code emitted multiple request classes and showed more cache-write volatility. If confirmed in other environments, that is not just an implementation detail; it affects gross margin for anyone routing paid API calls through coding agents.
Practical advice
First, measure at the API boundary. Log input tokens, cached input tokens, output tokens, request count, model, tool count, and accepted-task outcome. Do not rely only on CLI summaries.
Second, audit instruction files. Keep the rules that prevent bad edits, but remove stale policy text, duplicated examples, and long prose that does not change behavior. Split project-specific guidance from global style preferences when your tool supports it.
Third, trim MCP exposure. Attach only the servers needed for the task. Large always-on tool schemas are recurring input, not a one-time setup cost.
Fourth, treat subagents as an explicit budget choice. Use them for broad search, parallel investigation, or difficult debugging. Avoid them for narrow edits where one agent can inspect, patch, and test directly.
Finally, benchmark alternatives on your own repositories. Compare Claude Code, OpenCode, Codex, Cursor-style flows, and direct API harnesses using the same tasks. Track pass rate and review time alongside tokens. The cheapest route is the one that gets merged, not the one with the smallest first request.
Bottom line
The 33k vs 7k headline is important because it gives developers a concrete number for a hidden cost. But the bigger pricing story is the multiplier stack: baseline overhead, instruction files, MCP schemas, request count, subagents, cache writes, and output length all compound.
Claude API rates have not changed. What changed is the evidence that coding-agent harness design can move real-world cost as much as the model choice itself.
If you are running paid Claude coding workflows this week, pull one day of usage logs and answer three questions: how many tokens are sent before the prompt, how stable is the cached prefix, and what does each accepted change cost after retries? That is the budget signal that matters.
Sources: Systima’s Claude Code vs OpenCode benchmark, George Hotz’s related “I love LLMs, I hate hype”, and AI Pricing Guru’s live pricing dataset.