Chapter one established that output costs 5× input. This chapter is about the more useful fact underneath it: that ratio does not move.
Here is Anthropic's entire published ladder on 2026-08-05, per million tokens:
| Model | Input | Output | Cache write | Cache read |
|---|---|---|---|---|
| Fable 5 | $10 | $50 | $12.50 | $1.00 |
| Opus 5 | $5 | $25 | $6.25 | $0.50 |
| Sonnet 5 | $2 | $10 | $2.50 | $0.20 |
| Haiku 4.5 | $1 | $5 | $1.25 | $0.10 |
Now take the ratios:
| Model | Output ÷ input | Cache write ÷ input | Cache read ÷ input |
|---|---|---|---|
| Fable 5 | 5.00× | 1.25× | 0.10× |
| Opus 5 | 5.00× | 1.25× | 0.10× |
| Sonnet 5 | 5.00× | 1.25× | 0.10× |
| Haiku 4.5 | 5.00× | 1.25× | 0.10× |
Every ratio is identical across a 10× price range. The ladder is a pure scalar multiple — Fable 5 is Haiku 4.5 with every number multiplied by ten. Not approximately. Exactly.
What that means, and it is not obvious
The 5× premium is not a positioning decision made per model. It is structural — the same physical asymmetry between prefill and decode described in memory bandwidth is the product, showing up identically at every tier because it is the same hardware underneath.
The consequence is the point of this chapter:
Switching model tier scales your bill. It never changes the shape of your exposure.
If output is 60% of your spend on Sonnet 5, it is 60% of your spend on Haiku 4.5. You have made everything cheaper and changed nothing about what is expensive. Teams that respond to a high bill by downgrading the model are pulling the one lever that provably cannot rebalance input against output.
The only lever that changes the shape is emitting fewer output tokens.
Which is why reasoning models are the story
Google states it in the line item. On the Vertex pricing page, the row is not "output" — it is:
Price per 1M output and thinking tokens
Gemini 3.1 Pro: $12. Gemini 3.5 Flash: $9. Thinking and answering are the same meter.
This is the single largest change to app-layer cost in recent memory, and it is easy to miss because nothing in your code changes. A reasoning model that deliberates for 2,000 tokens before emitting a 200-token answer has billed you for 2,200 output tokens — eleven times the visible response, at the 5–6× output rate.
Against input pricing on Gemini 3.1 Pro, those 2,200 thinking-and-output tokens cost the same as 13,200 input tokens. You can attach a very large document for what one deliberation costs.
The cost of a reasoning model is not its price per token. It is how many tokens it thinks for, and that is a property of the prompt and the task, not the price list. It is also the one number vendors cannot publish for you.
Batch: half off, still expensive
Anthropic's pricing page states it plainly: "Save 50% with batch processing."
Applied to Sonnet 5, batched output falls from $10 to $5 per million. Real money, and the right default for anything asynchronous.
But note where it lands. Batched output at $5 is still 2.5× the unbatched input rate of $2. Halving the premium does not remove it. Even in the cheapest asynchronous mode available, generating remains multiples more expensive than reading.
The one calculation worth doing
Teams routinely choose between a cheap verbose model and an expensive concise one, and guess. Do not guess — the ratio being constant makes the arithmetic trivial.
Cost per request is (input × in_rate) + (output × out_rate). Because out_rate = 5 × in_rate at every tier, this collapses to:
cost ∝ in_rate × (input_tokens + 5 × output_tokens)
So the model tier is a single multiplier you can factor out, and the comparison reduces to whichever option has the smaller input + 5×output. A model five times cheaper per token wins only if it does not emit more than five times the output — and reasoning models routinely do exactly that.
The diagnostic
- What percentage of spend is output? Above ~50%, prompt engineering is close to irrelevant and response-length control is the whole game.
- Are you on a reasoning model, and do you log thinking tokens separately? If you cannot see them, you cannot manage them, and they are billed at the output rate.
- Is anything asynchronous still running synchronously? That is a 50% discount left on the table for a config change.
- Did you "fix" cost by downgrading the model? Check whether output share moved. It will not have. You reduced the scalar, not the shape.
What this chapter is not saying
It is not saying avoid reasoning models. They earn their cost on genuinely hard tasks, and a cheap model that fails a task costs infinitely more than an expensive one that succeeds.
It is saying the thinking is billed, at output rates, and it is invisible unless you measure it. The ratio constancy is what makes that manageable: because the premium is the same at every tier, you can reason about token counts alone and apply the price multiplier at the end.