Cost, quality & latency
Cost and latency now trade at a published rate on one model — a 4× band at constant quality — which leaves quality as the only corner of the triangle you still have to measure.
The same Claude Opus 5.5 request costs $2 or $8 per million input tokens depending on nothing but how fast you want the answer: half price through the Batch API, double price in fast mode. Two corners of the cost / quality / latency triangle are now an exchange rate you can look up, so the only question left is the one no vendor can answer for you — what quality does this step actually need. Get the cheap corner wrong and it bites hardest: Claude Haiku 5.5 is the one current model priced by prompt length, and a request whose prompt passes 100,000 tokens pays 5× on every token in it, cache hits included.
Step 1The three axes, with current prices on two of them.
Think in tiers, not parameters. Architecture, training data and post-training matter as much as size, most models never publish a parameter count, and every vendor ships roughly the same ladder: a small/fast tier, a balanced mid tier, a frontier tier. The ladder is the practical handle, and on Anthropic's published rate card as of October 2026 it looks like this.
Claude list prices, USD per million tokens, October 2026 Tier / model | Input | Output | Cache read | Output / input ----------------------|--------|--------|------------|--------------- Haiku 5.5 (≤100K) | 0.10 | 0.50 | 0.01 | 5× Haiku 5.5 (>100K) | 0.50 | 2.50 | 0.05 | 5× Sonnet 5.5 | 2.00 | 10.00 | 0.10 | 5× Opus 5.5 | 4.00 | 20.00 | 0.20 | 5× Fable 5.1 | 10.00 | 50.00 | 0.25 | 5× For comparison, the retired Opus 4.1 listed at 15.00 / 75.00.
Two things in that table are worth more than the absolute numbers. First, output costs 5× input on every current tier — a ratio that has held across a generation of models, which means any step that writes a lot is expensive at every tier and no model choice rescues it. Second, the ladder moves downward under you: Opus 5.5 at $4/$20 undercuts Opus 5 at $5/$25, which in turn is a third of what Opus 4.1 charged. That generational drift is why "use the biggest model" is rarely a default worth defending — last year's flagship capability is this year's mid tier, and it is cheaper this year than it was last year. The deflation essay works through why your bill nonetheless fails to fall by the same factor.
Latency is two numbers, not one: time-to-first-token, which is dominated by prefill over your whole prompt, and total generation time, which is dominated by output length. Interactive products live or die on the first; batch jobs care only about the second. Quality is not one number at all — a small model can match a frontier model on extraction or classification and fall apart on a twenty-step plan, which is exactly why a public leaderboard cannot answer the question and your own eval set can.
Step 2Cost and latency are no longer a trade-off you have to engineer — they are a price.
The classic framing of the triangle treated latency as a physical consequence of model size: you wanted it faster, so you moved down a tier and gave up quality. That is no longer the shape of the decision, because the same model is now sold at several speeds.
- Give up interactivity, get 50% off. The Batch API discounts input and output by half on every model. Opus 5.5 drops from $4/$20 to $2/$10. Nothing about the model changes; you are paying less for an answer that arrives asynchronously. See batch and async inference.
- Buy speed, pay 2×. Fast mode on Opus 5.5 lists at $8/$40 against the standard $4/$20, for faster output on the identical model. Latency has a sticker price now, and the sticker is 100% of the base rate.
- Together that is a 4× band at constant quality. $2 to $8 per million input on one model, decided entirely by how much you care when the answer arrives. Any argument about which tier to use should be settled after you have decided where in that band you sit, because the band is wider than the gap between some adjacent tiers.
Caching is the one lever that moves cost and latency in the same direction, because a cache hit skips the prefill it would otherwise redo. The multipliers are published: a cache read is 0.1× base input on most models, 0.05× on Opus 5.5 and Sonnet 5.5, and 0.025× on Fable 5.1 — $0.25 per million against a $10 base, a 40× discount on text you were going to resend anyway. Writes cost 1.25× base for the five-minute cache and 2× for the one-hour cache, so the five-minute cache pays for itself after a single read and the one-hour cache after two. For an agent that resends a stable system prompt and tool catalogue every step, this is the largest single number on the page. Prompt caching has the mechanics.
Quality is the only axis with no published exchange rate. That asymmetry is the practical content of the triangle in 2026: you can buy your way along two edges at known prices, and the third you have to measure. Teams that skip the measurement end up paying frontier rates for a classification step, or shipping a regression because the cheap tier was cheap.
Step 3The cheap corner has a cliff in it, and an agent walks off it mid-run.
Every current Claude model from 4.6 onward bills the full one-million-token window at one flat rate — in Anthropic's own words, "a 900k-token request is billed at the same per-token rate as a 9k-token request." There is exactly one exception, and it is the cheapest model. Haiku 5.5 is priced by prompt length: past 100,000 tokens, input, output, cache writes and cache reads all jump 5×. The rule is unusually specific, and each clause costs money:
- Prompt length counts all input tokens, including cache reads and cache writes. Caching does not keep you under the threshold — a 95,000-token cached prefix plus 10,000 tokens of fresh tool output is a 105,000-token prompt.
- Each request is priced on its own. A request over the threshold pays the higher prices even when most of its prompt is a cache hit, and earlier requests keep the prices they were billed at.
An agent loop accumulates context monotonically, so this is not a model choice you make once — it is a boundary your run crosses at some step index. Work it through. Say a stable 30,000-token system prompt and tool catalogue, 4,000 tokens of tool results appended per step, 500 output tokens per step, twenty steps. The prompt at step k is about 30,000 + 4,500k tokens, which passes 100,000 at step 16.
Twenty-step agent, Claude Haiku 5.5, no caching
input tokens rate cost
steps 1-15 (under 100K) 990,000 $0.10 $0.0990
steps 16-20 (over 100K) 555,000 $0.50 $0.2775
output, steps 1-15 7,500 $0.50 $0.0038
output, steps 16-20 2,500 $2.50 $0.0063
-------
total 1,545,000 $0.3865
Priced naively at the headline rate: $0.1595
Actual / estimate: 2.4×
Share of the bill in the last five steps: 73%
The estimate was wrong by a factor of 2.4, and the error is concentrated: five of twenty steps carry nearly three-quarters of the cost. Note what this does not say. Haiku 5.5 at $0.3865 is still roughly eight times cheaper than running the same loop on Sonnet 5.5 — the cheap tier is still cheap. What breaks is your forecast and the shape of your bill, which is the thing that makes a budget alarm fire at step 17 of a run you modelled as flat. If you forecast agent spend from a per-token headline, see forecasting agent spend for the discipline that catches this.
Step 4What to actually do with the triangle.
You do not have to pick one global point, and the strongest patterns all work by refusing to.
- Route, do not choose. Haiku 5.5 under the threshold is a twentieth of Opus 5.5 on input and a hundredth of Fable 5.1. Send everything to the cheap tier first and escalate on uncertainty or detected difficulty; most real traffic is easy, so most of it resolves cheaply and only the minority that needs the frontier pays for it. Model routing has the implementation.
- Tier by step, not by application. Inside one agent, a small model to classify and route, a reasoning model only for the genuinely hard planning step, a mid model to write the answer. The step is the unit of model choice.
- Compact before the cliff, not after. If you are on a length-priced tier, the threshold is a hard deadline for compaction, and context budgeting is what keeps you on the cheap side of it. If you cannot stay under, a flat-priced tier may be cheaper in total than a cheap tier at 5×.
- Right-size upward, never downward. Start from the smallest tier that passes your eval and move up only where it measurably fails. Starting at the frontier and trying to cut costs later is the same work done with worse information, because by then you have no measurement of what the cheap tier would have done.
- Price the unit you buy. Cost per completed task, not cost per token — a brevity win and a price cut are not the same discount on an agent loop, which fewer tokens vs cheaper tokens works out in closed form, and a tokenizer change can move your token count without anyone changing a price.
Do this in order. Decide the quality bar on your own eval; pick the smallest tier that clears it; then take whichever published exchange rate your latency requirement allows — batch if the answer can wait, fast mode if it cannot, standard otherwise; then cache the stable prefix, because that is the only move that improves both axes at once. And if your cheap tier is priced by prompt length, treat the threshold as a context budget, not a billing detail: an agent that does not know where the cliff is will find it at step 16.
Related: choosing a model for the per-task checklist, agent cost control for the loop arithmetic, small and local models for the case where the per-token price goes to zero and a throughput ceiling replaces it, and pricing latency for what a latency improvement is worth to the business paying for it.