Blog · 2026-07-14 · Vynaris Team
Your coding agent bills 33,000 tokens before it reads your prompt
Claude Code bills ~33,000 tokens of scaffolding before it reads your prompt; OpenCode ~7,000. A loaded 59,000-token prefix costs $295 per 1,000 requests on Claude Opus 4.8, $8.26 on deepseek-v4-flash. Prompt caching cuts 90%. Full math, prices verified 2026-07-14.
Claude Code sends about 33,000 tokens of system prompt, tool schemas, and injected scaffolding before your prompt arrives; OpenCode sends about 7,000, or 4.7x less. Add a 72KB CLAUDE.md (+20,000) and five MCP servers (+6,000) and the fixed prefix reaches 59,000 tokens, billed as input on every request. At Claude Opus 4.8 that is $295 per 1,000 requests of pure scaffolding, before the agent does any work. Token counts from Systima (2026-07-12); prices verified 2026-07-14.
TL;DR
- The scaffolding prefix is a fixed cost you pay on every request: $295 per 1,000 requests on Claude Opus 4.8 down to $8.26 on deepseek-v4-flash, for a 59,000-token loaded setup, and $0 of that buys any output.
- It is a pure input-token bill, so output price is irrelevant. Sort your model choice by input price, not the headline output number.
- Prompt caching drops the scaffolding cost 90% on every model here (98% on deepseek-v4-flash), because a stable prefix is the ideal cache target. The catch: a harness that churns the cache pays the 12.5x write penalty instead.
What we computed, and why
A coding agent does not send your question and wait. Before your first keystroke reaches the model, the harness has already assembled a system prompt, a set of tool schemas, your instruction file, and whatever your MCP servers advertise. That block is the same on every request in the session. It is input the model reads before it produces a single token of reply.
Systima measured these blocks directly and published the counts on 2026-07-12. We are not re-measuring them; we are taking their public token counts and attaching live prices to answer one question: what does the scaffolding alone cost across six models, before the agent does any actual work? Every number below is either a cited token count or an arithmetic step shown in full. The math is in a script; nothing here was estimated by hand.
The assumptions (edit these)
Every row is a public measurement or a price you can re-check. Swap your own instruction-file size or MCP count in and the totals move with it.
Component Tokens Source
---------------------------- ------------- -------------------------------------------------------------
Claude Code base scaffolding 33,000 Systima, 2026-07-12 (system prompt + tool schemas + injected)
OpenCode base scaffolding 7,000 Systima, 2026-07-12
72KB CLAUDE.md / AGENTS.md +20,000 Systima, 2026-07-12 (avg added per request)
Five modest MCP servers +6,000 Systima, 2026-07-12 (stated 5,000–7,000; midpoint)
*Loaded Claude Code prefix* *59,000* 33,000 + 20,000 + 6,000
Measured production setup 75,000–85,000 Systima, 2026-07-12 (before first user token)Our itemized 59,000 is deliberately conservative: Systima observed real working setups sitting at 75,000–85,000 tokens before the user typed anything, because live file reads and loaded context pile on top of the three components above. We use 59,000 as the headline so every token is traceable to a named source, and show the 80,000 case in the results table so you can see where a fully-loaded session lands.
Results: scaffolding cost per 1,000 requests, six models
Prices verified 2026-07-14 from the Anthropic, OpenAI, and DeepSeek pricing pages (sources below), standard first-party input rates. This is the scaffolding prefix only: no output, no user work, billed once per request with no caching.
Model Input $/1M Bare (33k) Loaded (59k) Full (80k)
----------------------------------------------------------------- ---------- ---------- ------------ ----------
[Claude Opus 4.8](https://vynaris.com/models#claude-opus-4-8) $5.00 $165.00 $295.00 $400.00
[gpt-5.6-terra](https://vynaris.com/models#gpt-5-6-terra) $2.50 $82.50 $147.50 $200.00
[Claude Sonnet 5](https://vynaris.com/models#claude-sonnet-5) $2.00 $66.00 $118.00 $160.00
[gpt-5.3-codex](https://vynaris.com/models#gpt-5-3-codex) $1.75 $57.75 $103.25 $140.00
[Claude Haiku 4.5](https://vynaris.com/models#claude-haiku-4-5) $1.00 $33.00 $59.00 $80.00
[deepseek-v4-flash](https://vynaris.com/models#deepseek-v4-flash) $0.14 $4.62 $8.26 $11.20
The ranking is the input price list, in order. Output price never enters the calculation, because scaffolding produces no output — it is context the model reads. This is the same lesson as the per-task coding-agent cost model: agents invert chat economics because they are dominated by what the model reads, not what it writes. If your model shortlist is sorted by output price, you are sorting on the wrong column. For a per-model input/output table across the wider field, see the July 2026 pricing breakdown.
Note the gap between Opus 4.8 ($295) and deepseek-v4-flash ($8.26): a 36x spread on identical scaffolding, paid on every request whether or not the model does anything useful with it.
Fresh input, cache read, cache write: the three rates that matter
The scaffolding prefix is stable across a session, which makes it the textbook candidate for prompt caching. Every provider here charges three different rates for the same tokens:
- Fresh input: full price, paid when the model reads tokens it has not cached.
- Cache read (cache hit): 0.1x the input price on Anthropic and OpenAI; 2% of the miss price on deepseek-v4-flash.
- Cache write: 1.25x the input price on Anthropic for a 5-minute cache; OpenAI and DeepSeek populate the cache on a normal miss with no write premium.
Once the prefix is cached, requests 2 through N read it at the cache-read rate. Here is the steady-state scaffolding cost per 1,000 requests on the loaded 59,000-token prefix:
Model Uncached /1,000 Cached read /1,000 Saving
----------------- --------------- ------------------ ------
Claude Opus 4.8 $295.00 $29.50 90%
gpt-5.6-terra $147.50 $14.75 90%
Claude Sonnet 5 $118.00 $11.80 90%
gpt-5.3-codex $103.25 $10.33 90%
Claude Haiku 4.5 $59.00 $5.90 90%
deepseek-v4-flash $8.26 $0.17 98%If you are about to pick a model on its sticker price, run your real prefix size and session length through the calculator first. The cached number is the one you will actually pay, and it reorders nothing but shrinks everything by 90%.
The uniform 90% is not a coincidence: cache read is 0.1x input on both Anthropic and OpenAI, so the discount is identical regardless of model. deepseek-v4-flash goes further because its cache hit ($0.0028/1M) is 2% of its miss price, not 10%. Turning caching on is the single highest-impact change most agent builders have not made, and it requires no model swap.
The tradeoff: cache churn costs more than no cache
Caching has a failure mode, and it is expensive. On Anthropic, a cache write costs 1.25x input while a cache read costs 0.1x, so re-writing a token you could have read costs 12.5x more. If a harness invalidates its cache mid-session and re-writes the prefix instead of reading it, caching becomes a penalty.
This is not hypothetical. Systima measured one harness writing 53,839 cache tokens across five requests on a task where another wrote 1,003, up to 54x more cache-write volume for the same work. That is about 10,768 tokens re-written per request that should have been cheap reads. The waste, priced out:
Model Wasted $/1,000 requests
---------------- -----------------------
Claude Opus 4.8 $61.91
Claude Sonnet 5 $24.77
Claude Haiku 4.5 $12.38That $61.91 on Opus 4.8 is pure overhead: money spent re-writing cache that a better-behaved harness would have read for a tenth of the price. Before you trust caching to cut your bill, confirm your harness holds the cache across requests instead of thrashing it. Cache churn is a bigger, quieter cost than the model you picked.
The subagent multiplier
One more public number worth pricing: Systima found a small task that cost 121,000 tokens run directly cost 513,000 tokens when fanned out to two subagents — a 4.2x blowup. Each subagent carries its own copy of the scaffolding prefix, so parallelism multiplies the fixed cost you just measured. Fan-out buys wall-clock speed and pays for it in tokens. Use it where latency matters and skip it where it does not.
What it means for routing
- Cache before you route. Caching cut the scaffolding cost 90% here with zero quality change. That is a bigger, safer win than most model swaps, and it comes first.
- Trim the prefix you control. A 72KB instruction file adds 20,000 tokens to every request. Half of most CLAUDE.md files is stale. Cutting it to 36KB saves 10,000 tokens per request — $50 per 1,000 requests on Opus 4.8, forever. Same for MCP servers you loaded once and never use.
- Sort candidates by input price. Scaffolding is input-only, so the right-sizing decision for read-heavy agent work tracks input price. A model with cheap input and expensive output suits this shape.
- Route steps, not sessions. Keep planning on a stronger model; send mechanical steps to a cheaper one. An OpenAI-compatible gateway lets you test that behind one base URL without rewriting provider glue — the model routing case in one sentence.
Where this model is wrong
- Token counts are one harness on one setup. Systima measured specific tools and a specific 72KB instruction file. Your scaffolding might be 20,000 tokens or 120,000. The point is the method, not our exact totals — measure your own prefix and re-run the script.
- Caching assumptions are best-case. The 90% saving assumes the prefix stays in the cache window and the harness reads instead of re-writes. The churn table shows what happens when it does not. Real sessions land between the two.
- We priced scaffolding only. This is the fixed cost before any work. The variable cost — the model actually reading files, reasoning, and writing diffs — sits on top, and we modeled that separately in the per-task teardown.
- Tokenizers differ. Claude Opus 4.7 and later and Claude Sonnet 5 use a newer tokenizer Anthropic states produces about 30% more tokens for the same text. A 33,000-token prefix measured on one tokenizer is not 33,000 on another. Compare within a tokenizer family, not across.
When is a fat prefix worth it? When the scaffolding is what makes the agent good. A rich system prompt and the right tool schemas can turn three failed cheap requests into one that works. If trimming context makes the agent dumber and it retries more, you paid to save tokens and spent more. Measure task success, not just token count — the cheapest request is the one you do not have to run twice.
FAQ
How many tokens does a coding agent send before my prompt? Systima measured about 33,000 for Claude Code and about 7,000 for OpenCode as base scaffolding (2026-07-12). A 72KB instruction file adds ~20,000 and five MCP servers add 5,000–7,000, pushing a loaded setup to ~59,000 and a fully-loaded production session to 75,000–85,000 before you type.
Why does scaffolding cost depend only on input price? Because the prefix is context the model reads, not text it writes. It generates no output tokens, so output price never enters the math. Sort models by input price for this cost.
Does prompt caching fix it? Mostly. A stable prefix cached and read costs 90% less on every model here (98% on deepseek-v4-flash). The exception is a harness that re-writes the cache mid-session, which pays the 12.5x write-vs-read penalty and can cost more than no caching.
What is the cheapest way to cut scaffolding cost without changing models? Turn on prompt caching, then trim the instruction file and unused MCP servers. Trimming a 72KB CLAUDE.md to 36KB saves ~10,000 input tokens per request — about $50 per 1,000 requests on Claude Opus 4.8.
Do subagents make this worse? Yes. Each subagent carries its own scaffolding copy. Systima measured a 121,000-token task ballooning to 513,000 across two subagents — 4.2x. Fan-out trades tokens for latency; use it only where speed matters.
Sources
- Systima, "Token Overhead Measurements: Claude Code vs OpenCode," 2026-07-12: https://systima.ai/blog/claude-code-vs-opencode-token-overhead
- Anthropic pricing (input rates, cache multipliers, tokenizer note), verified 2026-07-14: https://platform.claude.com/docs/en/docs/about-claude/pricing
- OpenAI API pricing (gpt-5.6-terra, gpt-5.3-codex input + cached input), verified 2026-07-14: https://developers.openai.com/api/docs/pricing
- DeepSeek API pricing (deepseek-v4-flash input, cache hit), verified 2026-07-14: https://api-docs.deepseek.com/quick_start/pricing
- Cost math script: reproducible from the assumptions table above.
Prices change. We re-verify every figure in this post monthly and stamp updates. Numbers are current as of 2026-07-14.
Want this math on your own setup? Vynaris is an OpenAI-compatible gateway that routes each request to the cheapest right-sized model and shows the per-request cost, scaffolding included. One base URL swap. Get an API key at vynaris.com.