Claude Code measured sending about 33K tokens before user prompt; OpenCode about 7K

Claude Code Burns 33K Tokens Before It Even Reads Your Prompt

The number that should make you check your API bill Someone finally put a logging proxy between an agentic coding CLI and the model endpoint instead of trusting the usage meter. The result, published this week and sitting at 500+ points on Hacker News: Claude Code sends ~32,800 tokens before your prompt is read. OpenCode sends ~6,900. Same task. Same "22 character" prompt. A 4.7x gap that has nothing to do with what you typed. This isn't a vibes complaint about "Claude feels expensive lately." It's a wire capture — actual JSON payloads, actual usage blocks, measured against a hash-verified test suite where both harnesses got the right answer. If you're running agentic coding tools in a loop all day, this is your context budget, and someone is spending it before you get a turn. Where the 33K actually goes The breakdown, from the Systima writeup: Claude Code, first request: System prompt: 27,344 characters across 3 blocks Tool schemas: 99,778 characters for 27 tools First-message scaffolding: 7,997 characters Your actual prompt: 22 characters OpenCode, first request: System prompt: 9,324 characters, 1 block Tool schemas: 20,856 characters for 10 tools Scaffolding: none Your actual prompt: 22 characters 27 tools versus 10. That's the headline lever — every tool definition is a schema blob shipped on every single request, whether you use the tool or not. Strip tools entirely and the system prompt alone is still 3x bigger on Claude Code (26,891 chars vs 8,811). The part that's worse than the baseline Baseline overhead is at least predictable — pay it once, cache it, move on. The uglier finding is cache behavior under a real multi-step task: Cache writes (5 requests, same task) Claude Code 53,839 tokens OpenCode 1,003 tokens 53.7x more cache writes for identical work. OpenCode "emitted byte-identical prefixes across every request and every run." Claude Code showed three distinct request classes per session with system bytes shifting underneath it — meaning the cache breakpoint keeps moving, meaning you keep re-paying for a prefix that should've been free. Anthropic's own pricing model depends on stable prefixes to make prompt caching worth anything. If the harness itself is the thing invalidating the cache, you're paying full input-token price for context you already sent. The number that actually matters: identical outcomes, 3.7x the cost Forget the cold-start number — that's a one-time tax. The real damage shows up on the ten-lane benchmark, five runs each, both harnesses passing every test: Claude Code: ~268,000 input tokens per passing run OpenCode: ~72,000 input tokens per passing run Same correctness. 3.7x the token spend. That's not overhead you pay once at session start — that's overhead compounding every turn of a working session. And it gets worse with agent fan-out. Spin up 2 subagents on Claude Code and cumulative tokens go 121K → 513K. A 4.2x multiplier stacked on top of the baseline 4.7x. If you're running subagent-heavy workflows, the two multipliers don't add — they compound. Before you torch your CLAUDE.md file, read the caveat The researchers were honest about the hole in their own methodology, and you should weigh it before treating this as gospel: "A single mid-task cache miss could in principle be our gateway evicting rather than the harness moving its cache breakpoints; reproduction across runs makes systematic harness behaviour the likelier explanation." Translation: they think it's the harness, not their proxy, because it reproduced — but they only ran this on one machine, with small sample sizes (three Sonnet runs, two Fable runs, five quality lanes), one implementation per condition, and a July 2026 snapshot of both tools. Both harnesses ship fast. This ratio could shrink or widen by the time you read this. What to actually do with this Audit your MCP server count. Five MCP servers added 4,900–6,967 tokens per request in the study — before you send a single prompt. If you've got a dozen servers wired in "just in case," you're paying rent on tools you never call. Watch your instruction file size, not just its content. A 72KB CLAUDE.md-equivalent added ~20,000 tokens per request on both harnesses. This one isn't Anthropic's fault — it's yours. Trim it. Be deliberate about subagent fan-out. 4.2x multiplier on top of baseline overhead means "let me spin up a few agents to parallelize this" is not a free move. Know the multiplier before you reach for it. If cost-per-task is your actual constraint — not raw capability — this data says try OpenCode side-by-side on your real workload before assuming the flagship harness is the efficient choice. "Every token of harness payload is a token of working context you cannot spend on your task." The tools that win the next two years of agentic coding won't just be the ones with the best model behind them. They'll be the ones that don't spend 33K tokens clearing their throat before they start working. Source data: Systima's wire-level analysis, methodology via logging proxy between harness and model endpoint, cross-referenced against the Hacker News discussion (500+ points, 300+ comments as of publication).

2 hours ago

Claude Code Sends 33k Tokens Before Your Prompt; OpenCode Sends 7k

A new side-by-side measurement shows Claude Code ships roughly 33,000 tokens of system prompt, tool schemas, and scaffolding before your prompt even arrives — about 4.7x the ~7,000 tokens OpenCode sends on the same setup. The bigger cost surprise is next: Claude Code re-wrote up to 54x more prompt-cache tokens per session, and cache writes bill at a premium. How the test was run The benchmark (published by Systima) spliced a logging proxy between each harness and the model endpoint, capturing the exact request payload and the API's usage block. Both harnesses were pinned to the same conditions: Claude Code 2.1.207 and OpenCode 1.17.18, both pointed at claude-sonnet-4-5 Fresh config directories, empty workspace, no MCP servers, no instruction files, permissions bypassed Tasks ranged from "reply with OK" (isolating fixed overhead) to a write-run-test-fix loop against FizzBuzz A zero-tools variant separated system-prompt weight from tool-schema weight The payload captures are exact; the only adjustment was subtracting a constant ~6,200-token gateway envelope that wrapped every request in the test setup. The fixed floor Harness Fixed overhead before your prompt Cache-write behavior Claude Code 2.1.207 ~33,000 tokens Re-wrote tens of thousands of cache tokens per run; up to 54x OpenCode OpenCode 1.17.18 ~7,000 tokens Byte-identical prefix each run; cached once, read back cheaply OpenCode's request prefix was byte-identical in every captured run, so it paid to cache its payload once per session and read it back for pennies. Claude Code re-wrote large amounts of prompt-cache tokens mid-session, run after run — and because cache writes bill at a premium, one usage dashboard climbs while the other stays flat. Where it piles on in real setups The harness floor is only the start. The benchmark added variables one at a time: A production repository's 72KB instruction file added an average of ~20,000 tokens to every request. Five modest MCP servers added 5,000–7,000 more. By the time a real working setup sends its first request, it is 75,000–85,000 tokens deep before you type a word. Behavior multiplies it further. A small task that cost 121,000 tokens done directly cost 513,000 tokens when fanned out to two subagents, because every subagent pays its own bootstrap and the parent then swallows the transcript. The nuance that cuts the other way One result favors Claude Code. On a multi-step task, its whole-task total came out lower than OpenCode's, because it batches tool calls into fewer requests while OpenCode re-pays its smaller baseline turn after turn. The meter starts higher for Claude Code; how the session unfolds decides who actually spends more. Overhead is not destiny — session shape matters. What you should do If you run agentic AI in production, the benchmark's core advice applies: you should be able to answer "what exactly did we send to the model?" with data, not folklore. Point ANTHROPIC_BASE_URL at a logging proxy, give the harness a fresh config and empty workspace for the floor, then add your instruction file, MCP servers, and workflows one at a time and watch the boundary. If your traffic passes through a gateway, measure its envelope with a bare request first. For the wider open-source-vs-paid trade-off behind these two harnesses, see our OpenCode vs Claude Code free-agent face-off, and for how model choice interacts with this overhead, our Claude Code vs Codex comparison breaks down the underlying models. Q1: Is Claude Code always more expensive than OpenCode because of the token overhead? Not necessarily. Claude Code starts with a much higher fixed overhead (~33k vs ~7k tokens) and writes far more cache tokens, which can spike cost. But on multi-step tasks it batches tool calls into fewer requests, and in the benchmark its whole-task total came out lower than OpenCode's. Session shape decides the final bill. Q2: Why do cache writes matter so much for cost? Prompt-cache writes bill at a premium compared to cache reads. OpenCode cached its prefix once and reused it cheaply; Claude Code re-wrote large cache payloads repeatedly, so the same logical content cost more per turn. Q3: How can I measure my own agent's token overhead? Put a logging proxy between your harness and the model endpoint, start with a fresh config and empty workspace to isolate the floor, then add your instruction file, MCP servers, and workflows one variable at a time. Subtract any gateway envelope you measure with a bare request first. Sometimes Claude writes better code. Sometimes GPT does. aiFiesta lets you compare both instantly in one chat for $12/mo — plus 7 more premium models.

16 hours ago