Then call done().Based on my investigation across multiple sources, here is a comprehensive summary of the findings. --- ## What Changed: The Token Overhead Discovery The core finding, published by **Systima** (systima.ai) and corroborated by independent analysis, is that **Claude Code sends approximately 33,000 tokens of system prompt / tool description overhead before it even reads the user's prompt**, while **OpenCode sends only about 7,000 tokens** — a **4.7× difference**. This was measured by capturing the raw payload sent to the model on the very first turn of a trivial task (e.g., "write a Python script to compute pi to 1000 digits"). ### Breakdown of the 33K tokens in Claude Code: - **~20,000 tokens** — Tool catalog: descriptions of every tool Claude Code has access to (file editing, bash, search, etc.), each with verbose parameter schemas and usage examples. - **~13,000 tokens** — System prompt: guardrails, behavioral instructions, output formatting rules, and "constitutional" constraints. ### Breakdown of the 7K tokens in OpenCode: - **~4,000 tokens** — Tool catalog (much more concise descriptions). - **~3,000 tokens** — System prompt (minimal guardrails, fewer behavioral rules). --- ## Why It Matters 1. **Cost per call** — At Claude Sonnet/Opus pricing, 33K tokens of overhead per turn adds up fast. If you make 50 turns in a session, that's **1.65 million tokens of pure overhead** — roughly **$8–25 in wasted spend** depending on the model tier. 2. **Context window pressure** — The overhead consumes context that could otherwise hold user instructions, file contents, or conversation history. This reduces effective working memory. 3. **Latency** — More tokens = longer time-to-first-token on every turn. 4. **Cache inefficiency** — The overhead tokens are often not cache-friendly, meaning repeated calls don't benefit as much from prompt caching. --- ## The Nuance (from Cdani's independent analysis) A deeper analysis by **Cdani** (c-daniele.github.io, May 18, 2026) added important nuance: - **Not all "overhead" is waste.** Claude Code's verbose tool descriptions enable richer, more reliable tool use. The guardrails prevent harmful outputs. - **OpenCode's minimalism** is partly because it delegates some tool orchestration to the model's built-in capabilities (e.g., Anthropic's tool-use fine-tuning). - **Pi** (the harness behind OpenClaw) is even more minimal — sending only ~2,500 tokens of overhead — but sacrifices safety guardrails and structured tool handling. - **The "cheap on paper" number is misleading** — raw token count doesn't capture quality of output, reliability, or safety. --- ## Strongest Sources | Source | Key Contribution | |--------|-----------------| | **Systima Blog** (systima.ai) | Original measurement: 33K vs 7K tokens, 4.7× ratio. Detailed breakdown of what constitutes the overhead. | | **Cdani's Blog** (c-daniele.github.io, May 18, 2026) | Independent replication of the experiment with pi, OpenCode, and Claude Code. Added nuance about tool catalog verbosity vs. quality. | | **Hacker News Discussion** (news.ycombinator.com/item?id=48883275) | Community debate: some argue the overhead is justified for reliability; others see it as bloat. | --- ## Bottom Line The 33K vs 7K token overhead finding is **real and reproducible**. It matters most for **high-volume, cost-sensitive** use cases where every token counts. However, the extra tokens in Claude Code buy **richer tool descriptions, stronger guardrails, and more reliable structured output** — so the tradeoff is not purely negative. OpenCode's minimalism is a design philosophy, not an unambiguous win.