Every request to Claude Code ships ~33,000 tokens before it touches your actual task. OpenCode sends ~6,900. That 4.8x floor — measured at the API level with a logging proxy pinned to claude-sonnet-4-5 across Claude Code 2.1.207 and OpenCode 1.17.18 — is the hidden tax you pay on every interaction, whether you're fixing a typo or refactoring a service (Systima benchmark, July 2026).

Thirty-three thousand tokens is the cost of the system prompt, tool schemas, and reminder blocks that arrive before your prompt is even parsed. That's nearly a seventh of a 200k context window, gone to ceremony. The question isn't which tool has lower overhead — it's whether the overhead buys you something that makes the larger number worth it.

The floor is deceptive

In an empty workspace with no configuration, Claude Code pays 27,344 characters across three system blocks and 99,778 characters of tool schemas across 27 tools. OpenCode pays 9,324 characters in one system block and 20,856 characters across 10 tools. Strip tools entirely — pure harness — and Claude's instruction set is still 3x larger (26,891 chars vs 8,811 chars).

These aren't startup costs paid once and forgotten. They're paid per request. Every call to the model carries this baggage.

The multipliers compound quickly

The floor is the best case. Real configurations add layers that multiply it:

Instruction files. A 72KB AGENTS.md or CLAUDE.md adds ~20,000 tokens per request to both tools. (Claude Code ignores AGENTS.md entirely — it only reads CLAUDE.md, which matters if your team standardizes on the former.)

MCP servers. Each small MCP server adds 1,000–1,400 tokens per request. With five servers: Claude Code's tool inventory grows from 27 to 69, OpenCode's from 10 to 52. The token cost hits +4,900 and +6,967 respectively. MCP servers are additive in both tools, but OpenCode starts from a lower base, so the multiplier feels less painful.

Subagents. This is where Claude Code's architecture can hurt. Fanning out to two subagents turns a 121k-token task into 513,000 tokens — a 4.2x multiplier. Each subagent boots its own system prompt, tool schemas, and context, paying the full floor cost independently.

Extended thinking. Everything above compounds again when thinking is enabled. Every multiplier gets a multiplier.

Where the gap closes

The overhead numbers are dramatic for single requests. But the real-world picture changes when you look at multi-step tasks.

In a write-run-test-fix loop (T3), Claude Code completed three requests totaling ~121k tokens by batching parallel calls. OpenCode made nine serial requests totaling ~132k tokens. The total token consumption converged because request count multiplies the baseline — and Claude Code's ability to parallelize reduced the number of requests.

This is the key insight: overhead per request matters most for single-turn interactions. For complex, multi-step tasks where parallelization kicks in, the total cost difference narrows or reverses.

The cache mirage

Both tools use prompt caching, but the economics differ sharply.

OpenCode sends byte-identical prefixes across all runs. Cache writes on a file-summarise task: 1,003 tokens. Cheap.

Claude Code generates three distinct request classes per session — warmup, main, subagent — whose system bytes vary between runs. Cache writes range from 36,899 to 53,839 tokens, which is 5.9x to 54x OpenCode's volume. And cache writes are billed at a premium (1.25x base for the 5-minute tier, 2x for the 1-hour tier).

Three costs survive caching entirely:

  • Cache writes re-paid after any idle window longer than the cache TTL (5 minutes or 1 hour)
  • Read costs × total request count (inflated by subagents and serial loops)
  • Context-window consumption — that 85k bootstrap consumes 40%+ of a 200k window regardless of cache hits

When each tool wins

The data points to a clear trade-off.

Claude Code wins when:

  • Your task is complex enough to benefit from parallel batching (3+ steps with independent sub-tasks)
  • You need the full tool surface (27 built-in tools plus MCP extensions)
  • The task justifies a rich instruction file with Claude-optimized conventions
  • You can afford the cold-start cost because the session will be long

OpenCode wins when:

  • Tasks are simple and single-turn (fixes, queries, small refactors)
  • Your configuration is lean — few MCP servers, short instruction files
  • You're iterating rapidly with many short sessions
  • Cache utilization matters to your budget

A real-world configuration illustrates the gap: OpenCode with 11 MCP servers and a 72KB instruction file runs at 90,817 tokens cold, with 179 tools and 277KB of schemas. Claude Code with 4 MCP servers, plugins, and instruction lands at 75,000 tokens cold with 118 tools. Both are expensive — but OpenCode's floor of 6,900 tokens means users who keep config lean pay dramatically less per request.

Practical guidance

If you're already using one of these tools, here's what to measure and optimize:

Audit your instruction file size. That 72KB CLAUDE.md is costing ~20k tokens per request regardless of tool. Can you trim it to essentials? Separate team conventions (which rarely change) from task-specific instructions (which belong in the prompt).

Count your MCP servers critically. Each one adds ~1k tokens per request. If a server serves a tool you use once a week, it's costing you on every call. Consider lazy-initialization patterns or dedicated sessions for infrequent tasks.

Understand your session patterns. If you start a new session for every small fix, cache is irrelevant and you're paying the full floor cost each time. Long-lived sessions amortize the bootstrap across many requests.

Watch your subagent usage. The 4.2x multiplier for two subagents is brutal. Reserve subagents for genuinely parallelizable work — not as a default execution mode.

Profile before you optimize. These numbers come from controlled benchmarks with claude-sonnet-4-5. Your mileage depends on model choice, network latency, and your specific configuration. Run your own measurement with a logging proxy to see where you're bleeding tokens.

The 33,000-token floor isn't an argument against Claude Code. It's a number that demands you understand your own workflow well enough to know whether the ceremony is worth the capability. For complex, parallel tasks, it clearly is. For a quick variable rename, you're burning tokens on fanfare your prompt didn't ask for.