Chat pricing trained a generation of buyers to think in one number: tokens in, tokens out, times two rates. An agent breaks that model in both directions at once. It re-sends most of its context on every turn — so the raw input count explodes — but most of that re-sent context is cacheable at a tenth of the price. It writes answers the user can read — but reasoning models also write thousands of tokens nobody will ever see, billed at the output rate. A team that budgets "a dollar a query" from chat-era intuition can be off by an order of magnitude in either direction on the same underlying task.
The providers itemize this whether or not you look. OpenAI's Responses API returns a usage object with exactly the structure the bill follows: input_tokens with an input_tokens_details.cached_tokens field, and output_tokens with an output_tokens_details.reasoning_tokens field. Anthropic's API separates cache creation from cache reads as distinct line items with their own multipliers. The bill's structure is public. What is missing from most budgeting spreadsheets is the habit of reading it.
The meter has four segments
Segment one: fresh input, full price. Every new token the agent has never processed — the user's message, tool results being read for the first time, file contents being injected into context. This is the only segment billed at the headline input rate. Segment two: cached input, the re-sent prefix — system prompt, earlier conversation, previously-ingested files — priced at a fraction of list. The published fractions cluster around a tenth: 0.1× reads on OpenAI and Anthropic, Gemini's context cache at roughly 10% of the interactive input rate, DeepSeek's cache hits at 2% of its miss price. In an agent loop that re-sends 95%+ of its context every turn, segment two is most of the raw count and almost none of the bill.
Segment three: visible output — the text, the tool calls, the answer. Billed at the output rate, which on every major provider is several times the input rate. Segment four: reasoning tokens, and this is the one the chat era never had. OpenAI's reasoning guide states it without hedging: "While reasoning tokens are not visible via the API, they still occupy space in the model's context window and are billed as output tokens." The same page warns that a model "may generate anywhere from a few hundred to tens of thousands of reasoning tokens", and that a response can hit max_output_tokens "before any visible output tokens are produced, meaning you could incur costs for input and reasoning tokens without receiving a visible response" — with a recommendation to reserve at least 25,000 tokens for reasoning and outputs when starting out. OpenAI's help center repeats the billing rule verbatim, so it is not a footnote; it is the product.
Put the docs' own example usage object on the desk: input_tokens: 75, output_tokens: 1186, reasoning_tokens: 1024. Our arithmetic on that single turn: 1,186 output tokens are billed, 1,024 are reasoning, so the visible answer is roughly 162 tokens. 86% of the output bill buys invisible text, and the turn costs 7.3× what its visible length suggests (1,186 ÷ 162) — before the output-rate multiplier even enters. Multiply that by an agent that calls the model dozens of times per task and "the answer was two paragraphs" stops being a cost estimate of any kind.
4x and 15x: the measured multipliers
The demand-side anchor comes from Anthropic's engineering write-up of its multi-agent research system, published June 2025. Three numbers in it matter. First, the cost: "agents typically use about 4× more tokens than chat interactions, and multi-agent systems use about 15× more tokens than chats" — the company's own usage data, not a benchmark. Second, the payoff: a multi-agent system with Claude Opus 4 as lead and Sonnet 4 subagents outperformed single-agent Opus 4 by 90.2% on their internal research eval. Third, the uncomfortable mechanism: in the BrowseComp evaluation, three factors explained 95% of performance variance, and token usage alone explained 80%. The architecture's main product is permission to spend more tokens — Anthropic says this in as many words: "multi-agent systems work mainly because they help spend enough tokens to solve the problem."
The same post is honest about where the pattern fails, and the failure mode is a billing one. Subagents "operate in parallel with their own context windows" — that isolation is the feature, and it is also the budget problem: each window starts cold, re-reads its own materials, and cannot inherit another agent's cached prefix. Anthropic explicitly cautions that tasks requiring all agents to share context, and "most coding tasks", fit multi-agent architectures poorly. Read that against the token multipliers and the shape of the bill becomes clear: the 15× is a raw-token multiplier, and caching is what converts raw tokens into money — so the architectures that burn the most raw tokens are also, structurally, the ones with the worst cache hit rates.
What the bill actually looks like
Run one workload through the four-segment meter (our arithmetic throughout; the multipliers are the providers' published rates, the workload is constructed). A single research agent runs a 20-turn loop. Its context grows to ~150K tokens, averaging 100K re-sent per turn: 2M raw input tokens across the session. Suppose 90% of that re-sent context hits cache at 0.1×: billed input weight = 1.8M × 0.1 + 0.2M × 1 = 0.38M input-equivalents — the naive 2M count overstates the input bill by ~5.3×. Now the output side: the agent emits 15K visible tokens plus 60K reasoning tokens across the run, all billed at the output rate. Whatever your output rate is, 80% of the output bill is invisible text (60K ÷ 75K), and the two "savings" and "overruns" land on different segments: caching is why the input line survives, reasoning is why the output line doesn't.
Split the same task three ways — a lead agent plus two subagents, each with its own window — and the raw token count goes to roughly the 15× regime Anthropic measured, while the cache story inverts. Each subagent re-reads overlapping source material in its own cold window; the identical prefixes that would have been one cache entry in a single process are now three, one per agent, each paid for. Our arithmetic on the shape of it: a multi-agent run can easily carry a lower cache-hit ratio than the single-agent version of the same task, which means the bill multiplier moves toward the raw 15× rather than away from it. The chat-to-multi-agent jump Anthropic measured is 4×→15× in tokens; whether that is 4×→15× in money depends almost entirely on how much of the extra spending still lands on the cache-read segment. This is the analysis layer of the infrastructure stack, and it obeys the same rule as every layer below it: the naive count is not the bill, and the gap is where the engineering lives.
One more segment interaction is worth naming because it is a silent budget killer: reasoning tokens are output, and output is not cacheable. A model that burns 20,000 reasoning tokens to produce 500 visible ones has written 40× its visible length into the only segment with no discount tier. Anthropic's caching write multiplier (1.25× for the 5-minute tier, 2× for the 1-hour tier) at least amortizes — a cache write is paid once and read at 0.1× thereafter. Reasoning spend is paid at full output price, every single time, with no read-back mechanism at all. When OpenAI recommends reserving 25,000 tokens for reasoning and outputs, a buyer should read that number in price terms: at typical output-to-input ratios it is the single largest line in the whole budget.
Five questions before you deploy an agent
One: are you reading the usage object or the chat transcript? Every segment above is a field in the response — cached_tokens, reasoning_tokens — and every budgeting mistake we have described starts with someone estimating from what the user saw. Log all four segments per turn, from day one. Two: what is your reasoning budget per turn, and is max_output_tokens set to enforce it? OpenAI's own guidance is to reserve at least 25,000 tokens for reasoning and outputs — decide whether that reserve is a floor you want on every one of an agent's dozens of calls, or a ceiling you want to negotiate down per call. Three: what fraction of re-sent context actually hits cache in your workload? The gap between the raw input count and the bill is this number; if you cannot measure it, you are budgeting blind. Four: does the task genuinely parallelize? Anthropic's own verdict is that breadth-first research does and most coding does not — a multi-agent split that fragments your cache to buy parallelism can cost more than it buys. Five: what is the failure bill? An agent that crashes at turn 18 has paid for 18 turns of input-side caching and output-side reasoning that produced nothing; retries are not free in this meter the way they are in a chat.
That last question is where this series usually lands, and it lands here too. Agent economics are a demand-side mirror of the utilization tax this forum has priced from the supply side: rented GPUs run at 30-50% of nameplate, and rented context gets re-read at whatever discount the cache grants. Anyone building across distributed providers rather than a single vendor's API has one more segment to manage — the same prefixes re-cached at each provider, the same reasoning burned against each meter — which is one reason the honest pitch for distributed compute remains inference serving rather than agent hosting (omc.network). The meter is the meter everywhere; what differs is how many times you pay for the same prefix.
The wider point is the one this series keeps hitting from new directions. 2026's AI cost story is not a single rate per token; it is a four-segment meter with two discount regimes and one uncapped, undiscountable segment — invisible thinking. The teams that save money on agents are not the teams that found a cheaper model. They are the teams that read the usage object, measured their own cache-hit ratio, capped their reasoning spend, and refused to split a task into agents until the parallelism paid for the fragmentation. The bill was always itemized. Most budgets just never open the envelope.
Comments