News · 2026-07-12

Someone put a wiretap on two coding agents. One sends five times more before you type a word.

An applied-research engineering firm called Systima put a logging proxy between two popular AI coding agents and the model they call, captured the exact JSON of every request, and measured that Claude Code sends about 33,000 tokens of system prompt, tool schemas, and injected scaffolding before your prompt even arrives -- versus about 7,000 for OpenCode on the same one-line task. That is a 4.7x gap in fixed overhead for an identical outcome, and both agents produced correct results, so the difference is pure cost, not quality.

Key facts

• Claude Code 2.1.207 sent ~33,000 tokens of fixed overhead vs OpenCode 1.17.18's ~7,000 on a one-line prompt (pinned to Claude Sonnet 4.5).
• Tool schemas dominate: ~24,000 of Claude Code's ~33,000 tokens are the 27 tool definitions it ships (OpenCode ships 10).
• In a file-summarize task, Claude Code rewrote 53,839 prompt-cache tokens across 5 requests vs OpenCode's 1,003 -- a 5.9x to 54x gap.
• Measured 12 July 2026 by Systima using an HTTP intercept proxy over 185 request/response records with a hash-chained audit trail. Blog post, Hacker News discussion.

Here is the hook: every token an agent sends costs money and time, and most of what these tools send is invisible plumbing you never see. Systima's teardown makes it visible. To understand why the numbers are large, you need one idea about how these systems are billed. Language models re-read the entire conversation on every turn, so agents lean on prompt caching: the stable opening chunk of a request -- system prompt plus tool definitions -- is cached once and read back cheaply on later turns. That only works if the opening chunk is byte-for-byte identical each time.

This is where the real finding lives. OpenCode's request prefix was byte-identical in every run Systima captured -- a stable cache prefix, paid for once, read back for pennies. Claude Code instead rewrote tens of thousands of cache tokens mid-session, meaning it paid premium write rates again and again for content it had already sent. As Systima put it, "Re-writing a byte-identical cache prefix mid-session buys no code quality at all; it is the same content, paid for again at premium rates." The gap ranged from about 6x to 54x depending on how warm the cache was, and it replicated on a second model family (Claude Fable 5).

Think of it like a delivery driver who re-reads the entire instruction manual out loud at every doorstep instead of memorizing the first page once. The manual does not get better each time; you just pay for the reading. OpenCode memorized the first page. Claude Code, in these tests, kept re-reading it.

Two more findings sharpen the picture. First, the tested Claude Code version silently ignored an AGENTS.md instruction file, only ingesting it when renamed CLAUDE.md -- OpenCode reads either name. A silently-ignored instruction file is worse than no file: you think your rules are in force and they are not. Second, subagents are the real budget sink. A 121,000-token task fanned out to two subagents cost 513,000 tokens -- a 4.2x multiplier -- because each subagent re-bootstraps its own overhead and the parent then consumes its transcript. That matches the loudest complaint on Hacker News, where the top commenter wrote, "I gave Claude Code a pretty big task, and it immediately launched 7 sub agents which burned through my budget before even one of them was finished."

Why it matters: efficiency has quietly become the competitive front line among coding agents, and this is the first careful measurement of it. The same overhead that shows up here is what makes long agent sessions expensive and what the research world is now attacking architecturally (see the emerging work on giving agents better memory).

An honest caveat, which Systima states plainly: this is a July 2026 snapshot of one machine and one version pair, with small sample sizes (three runs per tier). A local model gateway sat in the measurement path; the authors measured its envelope and subtracted it, but acknowledge some warm-run numbers were "unattributable" and only quote cold-cache anchors. And Claude Code is not strictly worse -- on a multi-step write-run-test-fix loop it batched tool calls into three requests where OpenCode serialized into nine, and its whole-task total came out lower, because whole-task input roughly equals the baseline times the request count. The lesson is not "one tool is bad" but that agent design choices -- how you cache, how you batch, whether you spawn subagents -- move cost by multiples for the same result.

Primary source, verified: read the paper →

Ground Truth. (2026, July 12). Someone put a wiretap on two coding agents. One sends five times more before you type a word.. Ground Truth. https://groundtruth.day/news/coding-agent-token-overhead-measured.html

@misc{groundtruth:coding-agent-token-overhead-measured,
  title  = {Someone put a wiretap on two coding agents. One sends five times more before you type a word.},
  author = {{Ground Truth}},
  year   = {2026},
  month  = {jul},
  url    = {https://groundtruth.day/news/coding-agent-token-overhead-measured.html}
}

Topics: coding-agents · tokens · cost · claude-code · opencode · efficiency