Claude Code Burns 33,000 Tokens Before Your Prompt Arrives — We Counted Every One

The Number That Stopped Me

Here's the stat that broke my brain this week: 33,000 tokens.

That's how much text Claude Code sends to the model before it even reads your prompt. OpenCode, running on the exact same model (claude-sonnet-4-5), sends about 7,000.

The analysis comes from Systima, who spliced a logging proxy between each harness and the model endpoint to capture ground-truth payloads. No estimates, no cherry-picked screenshots — real API call data across three benchmark tasks.

These numbers matter because token overhead is the silent tax on every AI coding session. You don't see it in the billable usage, you don't feel it in the latency directly, but it compounds with every turn, every MCP server, every instruction file, every subagent. By the end of a real session, it can quadruple your costs compared to what you'd naively expect.

Let me break down exactly where those tokens go and why it matters for your daily workflow.

Where 33,000 Tokens Come From

The systima analysis breaks the first-turn payload into four components:

The dominant term for both is tool schemas — roughly 24k of Claude Code's tokens are tool definitions. Claude Code ships a massive orchestration suite: cron creation, background monitors, task management, worktree management, push notifications. OpenCode ships a leaner set focused on file operations and command execution.

Even stripped of all tools (pure harness system prompt), Claude Code is 3.25x larger: ~6,500 tokens vs OpenCode's ~2,000. That's just the behavioral doctrine — safety rules, tone guidance, task management protocols, environment descriptions.

The Cache Surprise — This Is the Real Story

The first-turn overhead is striking, but the cache economics is where costs really diverge.

Here's the smoking gun: Claude Code's request prefix is unstable. OpenCode emitted byte-identical prefixes across every request and every run — perfect cache hits, maximum discount. Claude Code, by contrast, generated multiple distinct prefix classes and was observed re-writing ~43,000-token full prefixes mid-session.

The result? Cache-write volumes ranged from 5.9x to 54x higher than OpenCode on the same tasks. And cache writes bill at a 1.25x–2x premium from most providers.

Three costs survive prompt caching even at its best:

1. The write itself — re-paid after every long pause that exceeds the cache TTL
2. The read times request count — inflated by subagents and serial tool loops
3. Context-window consumption — immune to caching entirely. An 85k-token bootstrap occupies 42% of a 200k window before any code arrives.

That third point is the one that keeps me up at night. Even if caching eliminates the cost of re-sending those tokens, it doesn't free up the space. Every reasoning step, every file read, every git diff has to squeeze into whatever's left after the harness has taken its cut.

When the Gap Closes (and When It Widens)

Counterintuitive finding: on a multi-step task (write-run-test-fix loop), Claude Code's cumulative total came out lower than OpenCode's — ~121,000 tokens vs ~132,000.

How? Parallel tool batching. Claude Code fires multiple tool calls in a single round trip. OpenCode serializes: one tool per turn. Request count multiplies baseline, and a large-baseline harness that batches aggressively can beat a lean harness that serializes.

This is the subtle trade-off: Claude Code's heavier baseline punishes short, simple tasks, but its batching efficiency can close the gap on complex, multi-step workflows. The shape of your work determines which side of that curve you land on.

The Multipliers Will Get You

The baseline numbers are for empty repos with no configuration. Real-world setups change everything:

• Instruction files (CLAUDE.md / AGENTS.md): A 72KB instruction file adds ~20,000 tokens per request for both harnesses. Gotcha: Claude Code ignores AGENTS.md — it only reads CLAUDE.md. If your project uses the wrong filename, that file is silent dead weight.

• MCP servers: Roughly 1,000–1,400 tokens per small server, per request. Five servers grew Claude Code's tool count from 27→69 and OpenCode's from 10→52. Production servers with rich APIs are much larger.

• Subagents: The biggest multiplier of all. A task that cost 121,000 tokens done directly cost 513,000 tokens when fanned out to two parallel subagents. Every subagent pays its own full bootstrap, and the parent then ingests the entire transcript. That's a 4.2x multiplier.

• The "everything" configuration: Systima's real-world T1 test (MCP servers + plugins + instruction file) clocked OpenCode at ~90,817 tokens for its cold write and Claude Code at ~75,000 tokens. That's roughly a 12x multiplier against OpenCode's bare 7k floor.

What This Means for Your Daily Work

For casual use and simple tasks: OpenCode's lean overhead is a clear win. If you're doing quick edits, reading files, or running one-off commands, you're paying 4.7x less token overhead per turn. On a $/token basis, that adds up fast over a day of coding.

For complex multi-step workflows: The calculus is murkier. Claude Code's batching efficiency can offset its baseline overhead on tasks that need 5+ tool calls. But you need to be running those kinds of tasks consistently to break even.

For production agent pipelines: Cache stability is the deciding factor. If you're running the same harness across hundreds of sessions (CI, code review bots, automated refactoring), OpenCode's byte-identical prefixes mean near-perfect cache economics. Claude Code's prefix instability means you're paying for cache writes you shouldn't need.

For subagent-heavy architectures: Both harnesses get expensive fast, but Claude Code's larger subagent bootstrap (3,554 chars system + 24 tools vs OpenCode's 1,379 chars + 5 tools) compounds with every parallel agent you spin up.

The Bottom Line

Systima's tagline says it best: "The harness sets the floor; your configuration sets the bill."

33,000 tokens is a real floor — higher than I think most Claude Code users realize. Whether it matters depends on your task shape, your MCP setup, and whether you're paying by the token or on a flat subscription. But the cache instability finding is the one I'd watch closest. In a world where every provider is racing to offer better prompt caching, a harness that can't keep its prefix stable is leaving money on the table.

The takeaway isn't "Claude Code bad, OpenCode good." It's: measure your actual token consumption. Systima's methodology — a logging proxy between harness and model — is something every serious team should replicate for their own configuration. The numbers you get will surprise you.