In July 2026, Systima published a boundary-level comparison of Claude Code and OpenCode on the same model, machine, and tasks. The headline number is blunt: for a one-line reply, Claude Code sent roughly 33,000 tokens of system prompt, tool schemas, and scaffolding before the user prompt arrived. OpenCode sent about 7,000.
That gap is not a model quality story. It is a harness story — what the coding agent ships on every request, how prompt caching behaves mid-session, and which multipliers (instruction files, MCP servers, subagents) turn a high floor into a painful meter.
This article unpacks what Systima measured, where Claude Code’s batching sometimes closes the gap, and what builders should change when agentic coding costs climb without obvious task complexity.
The floor: what “saying OK” actually costs
Systima put a logging proxy between each harness and the model endpoint, capturing request payloads and API usage blocks. Both harnesses were pinned to the same model in the primary matrix (claude-sonnet-4-5), with a reduced re-run on Claude Fable 5.
The minimal task was 22 characters: reply with exactly OK.
| Component | Claude Code | OpenCode |
|---|---|---|
| System prompt | ~27k chars, 3 blocks | ~9k chars, 1 block |
| Tool schemas | 27 tools, ~100k chars | 10 tools, ~21k chars |
| First-message scaffolding | Injected reminder / skill catalogues | none |
| User prompt | 22 chars | 22 chars |
| First-turn payload (approx) | ~32,800 tokens | ~6,900 tokens |
Tool schemas dominate both floors — roughly 24,000 of Claude Code’s ~33k tokens versus ~4,800 of OpenCode’s ~7k. Claude Code’s tool list includes the coding core plus background agents, orchestration (Task, worktrees, cron, monitors), and related platform surface. OpenCode ships a smaller classic coding toolset.
Strip the tools entirely and the system prompts alone still differ: Claude Code ~6.5k tokens of behavioural doctrine versus OpenCode ~2.0k. Even with zero tools, Claude Code’s instruction set is more than three times larger.
Think of the harness as the weight of the toolbox you carry into every room. OpenCode brings a compact kit. Claude Code brings a workshop — useful when you need the workshop, expensive when you only need a screwdriver.
Every token of harness payload is a token of working context you cannot spend on the task.
A ~33k baseline also burns context window: on a 200k window, the first turn starts roughly a sixth of the way in before any project code is discussed.
Cache behaviour: why the usage meter climbs
Systima’s second headline is cache inefficiency, not only payload size.
OpenCode’s request prefix stayed byte-identical across captured runs in a session: write the cache once, then read it back cheaply. Claude Code re-wrote tens of thousands of prompt-cache tokens mid-session, and on the same task wrote up to 54× more cache tokens than OpenCode. Cache writes are billed at a premium — that is why dashboards climb even when the user feels they are doing the same work.
On a simple read-and-summarise task (T2), both harnesses produced correct answers, but cumulative metered input diverged sharply: Claude Code ~199,000 tokens across 6 requests versus OpenCode ~41,000 across 4 (plus a small title call). Most of those tokens are discounted cache reads — but first-turn writes, per-turn reads, and context-window pressure still scale with the baseline.
When the gap closes — and when it does not
The multi-step write-run-test-fix task (T3) inverted the simple floor story on Sonnet:
| Metric | Claude Code | OpenCode |
|---|---|---|
| Model requests | 3 | 9 (+1 title call) |
| Tool-calling style | Parallel batch in one round trip | One tool call per turn |
| Cumulative metered input | ~121,000 | ~132,000 |
Claude Code paid a larger baseline fewer times. OpenCode paid a smaller baseline many times. Whole-task cost roughly tracks baseline × request count, plus conversation growth. Aggressive batching can make the hungrier harness cheaper on a short multi-tool job.
That advantage is not a harness constant. On Fable 5, Claude Code took six requests instead of three (including a large mid-session cache rewrite) and landed near ~298,000 tokens versus OpenCode’s ~133,000. Claude Code also sent a smaller, model-conditional system prompt to Fable than to Sonnet — the floor gap shrank to roughly 3.3× by payload versus 4.7× on Sonnet, but the multi-step totals still favoured OpenCode.
Multipliers that turn a floor into a bill
Systima stacked realistic production knobs on top of the floor:
Instruction files. A real 72KB AGENTS.md / CLAUDE.md added ~20,000 tokens per request to both harnesses. Claude Code 2.1.207 ignored AGENTS.md until renamed CLAUDE.md. A heavy instruction file nearly quadruples a lean harness’s baseline and rides every turn.
MCP servers. Roughly 1,000–1,400 tokens per small server per request. Five modest servers added ~5–7k tokens and ballooned tool counts (Claude Code 27→69 tools; OpenCode 10→52). Rich production APIs cost more.
Subagents. Fan-out multiplies full baselines. A small task that cost ~121,000 tokens done directly cost ~513,000 when fanned to two subagents — each subagent reloads its own system prompt and tools. The parent only ingest results, not full transcripts, but the meter still sees multiple bootstraps in flight.
Framework templates. Story/persona frameworks inject large prompts that re-travel with every subsequent request: template size × request count, stacked on everything else.
By the time a real setup adds instruction files and a handful of MCP servers, Systima estimates 75,000–85,000 tokens before the user has typed a word.
What this means for builders
If you run Claude Code, OpenCode, or any agent harness in production:
- Measure at the API boundary (payload + usage), not only at the product usage UI.
- Treat the floor as a product choice: platform-rich tools versus lean kits.
- Keep
CLAUDE.md/AGENTS.mdshort; move rare doctrine into on-demand skills or docs the agent fetches when needed. - Audit MCP schemas — each server is a permanent per-request tax.
- Use subagents when parallelism buys wall-clock time you need; do not fan out by default.
- Do not assume batching will always beat a smaller baseline; re-check when the model or harness version changes.
If you build harnesses: stable, byte-identical prefixes matter as much as smaller prompts. Cache-friendly payloads save more money than shaving a few hundred tokens of marketing copy in the system prompt.
Conclusion
Systima’s comparison makes harness overhead concrete: Claude Code’s ~33k-token floor versus OpenCode’s ~7k is a design trade-off between platform capability and meter burn. Cache rewrite behaviour, instruction files, MCP, and subagents decide whether that floor stays expensive for the whole session.
The useful question for teams is no longer “which agent feels smarter on day one.” It is “what does our agent actually send, how often does the prefix change, and which multipliers have we attached by default?” Answer that with boundary data — then trim the toolbox you carry into every room.