Token prices fell 73% and the same answer costs 2.7 times more

Per-token list prices fell 73.3% between Claude Opus 4.1 and Claude Opus 5.5. The same answer costs 2.7 times more, because one call became a ten-turn agent loop and a newer tokeniser counts roughly 30% more tokens for the same text. Cache both shapes and the loop wins until the single call’s prefix lands warm 59.6% of the time.

No number here was measured by anyone at this firm; each is quoted from a vendor’s pricing page with the date I read it, or derived from figures printed above. The question is whether a falling unit price is worth anything to whoever signs the invoice. It’s worth something. Not what the headline suggests.

Will AI tokens get cheaper?

Per token they already have, and two pricing pages prove it. OpenAI’s API pricing page, read on 29 October 2026, lists gpt-4-0613 at $30.00 per million input tokens and $60.00 output, and gpt-6-luna on the same page at $0.10 and $0.50: 30.00 ÷ 0.10 = 300x on input, 60.00 ÷ 0.50 = 120x on output. Anthropic’s pricing page, read the same day, runs a shorter span. Claude Opus 4.1 lists $15 and $75 per million; Claude Opus 5.5 lists $4 and $20. (15 − 4) ÷ 15 = 73.3%, and (75 − 20) ÷ 75 gives the same 73.3%.

Then the Haiku rows on the same table. Claude Haiku 3.5 is $0.80 per million input, Claude Haiku 4.5 is $1, and Claude Haiku 5.5 is $0.10 for prompts up to 100,000 tokens. The cheap tier went up 25% across one generation and down 90% across the next.

Up a quarter, then down nine tenths: the floor is not drifting, it is being repriced on a schedule of its own, and it alone prices by prompt length.

Why your LLM API bill went up when token prices went down

Your bill went up because the unit count rose faster than the unit price fell. Lamplighter carries the rest of this article: an invented document-retrieval system over a contracts archive, taking 1,000 contracts a month. It is a teaching instrument — not a client, a past employer or a composite of either — and every parameter is picked so the division comes out checkable.

The single-shot shape answers a question in one call: a 1,600-token prefix, a 100-token question, and six clauses at 750 tokens each from a vector search. So 1,600 + 100 + 6 × 750 = 6,200 input tokens against a 400-token answer. I price it on Claude Opus 4.1, retired on 5 August 2026 by Anthropic’s Model deprecations page, twelve months after the release date in its API name claude-opus-4-1-20250805.

The loop shape sends that question to a tool-calling agent picking its own next clause, ten turns deep. Every turn resends everything before it. Under Tool use pricing Anthropic says a request is priced on “the total number of input tokens sent to the model (including in the tools parameter)”, and lists “tool_result content blocks in API requests” among the extra tokens. A tool result isn’t billed once. It’s billed once per remaining turn.

Whether an open loop should have replaced named steps is a different argument, costed on twelve turns; these ten are another run of it.

Check what an agent loop costs against one API call

Sum the per-turn column and the ten-turn loop lands at 7.75 times the single call, on identical text at identical prices. Every token count here is in old-tokeniser units, so both shapes sit on the same text; the newer tokeniser arrives next.

The 1,600-token prefix is identical in both shapes, so the only thing moving is the loop. 286 of those tokens are not mine: Anthropic’s tool-use parameter table puts the system prompt for tools at 286 tokens on Claude Sonnet 5.5 under tool_choice: auto. The other 1,314 are Lamplighter’s instructions and tool schemas, and each turn adds a 750-token clause plus a 120-token record of the call, so the prompt grows 870 tokens a turn. The ten turns are mine too; no vendor publishes a turn-count distribution.

turn k input = 1,700 + (k - 1) x 870

  k        1      2      3      4      5      6      7      8      9     10
  in   1,700  2,570  3,440  4,310  5,180  6,050  6,920  7,790  8,660  9,530

Add that row yourself: 56,150, which input(n) = 1,700n + 435n(n − 1) reproduces as 17,000 + 39,150 at n = 10. Output is 120(n − 1) + 400 = 1,480. On Claude Sonnet 5.5 at $2 and $10 per million, the single call costs 6,200 × 2 ÷ 1,000,000 + 400 × 10 ÷ 1,000,000 = $0.0164, and the loop 56,150 × 2 ÷ 1,000,000 + 1,480 × 10 ÷ 1,000,000 = $0.1271. And 0.1271 ÷ 0.0164 = 7.75.

Roughly 30% more tokens for the same text

A Claude 4.7-or-later model charges less per token and counts roughly 30% more of them for the same text, so the 73.3% cut is really 65.3%. The sentence sits under the model table on Anthropic’s pricing page:

Claude 4.7 and later models and Claude Mythos Preview use a newer tokenizer that contributes to their improved performance on a wide range of tasks. This tokenizer produces approximately 30% more tokens for the same text.

Claude Opus 4.1 sits on the old tokeniser and Claude Opus 5.5 on the new, so on the same text the ratio is 1.3 × 4 ÷ 15 = 5.2 ÷ 15 = 0.3467. A 65.3% cut, not 73.3%. You pay less per token for more tokens.

Put the two together. On Claude Opus 4.1 the single shot is 6,200 × 15 ÷ 1,000,000 + 400 × 75 ÷ 1,000,000 = $0.1230. The loop runs the same text through Claude Opus 5.5’s newer tokeniser: 56,150 × 1.3 = 72,995 input and 1,480 × 1.3 = 1,924 output, so 72,995 × 4 ÷ 1,000,000 + 1,924 × 20 ÷ 1,000,000 = $0.33046. And $0.33046 ÷ $0.1230 = 2.687.

7.75 × 0.3467 = 2.687, the turn multiplier times the same-text unit-price ratio. Both routes print 2.7x.

A second overhead compounds with the turn count rather than the text. The Pricing section of Anthropic’s Steering thinking page, its penultimate heading at about 92% down, bills thinking blocks left in context by earlier turns “as input tokens”. The Extended thinking page draws the line at Claude Opus 4.5, and at every model numbered 4.6 or higher. So the newer, cheaper models carry earlier reasoning forward as billable input. How much that adds I don’t know. Anthropic prints one example: 312 thinking tokens inside 348 output, or 89.7%. That is a documentation example, not a measurement.

What is the break-even hit rate for prompt caching?

About 22% of calls on the five-minute cache and about 53% on the one-hour one, far enough apart to decide which lifetime you reach for. Anthropic’s prompt caching prices put a 5-minute write at “1.25x base input price”, a 1-hour write at “2x base input price”, and a cache read at 0.1x of base input, or 0.05x if you are on Claude Opus 5.5 or Claude Sonnet 5.5 and 0.025x on Claude Fable 5.1. Hold base input at 1 and the algebra is two lines.

uncached call = 1
cached call   = w(1 - h) + r*h      w = write multiplier, r = read multiplier, h = hit fraction
break-even      w(1 - h) + r*h = 1   ->   h = (w - 1) / (w - r)

With the standard 0.1x read, the five-minute write gives h = 0.25 ÷ 1.15 = 21.7% and the one-hour write h = 1 ÷ 1.9 = 52.6%. Run OpenAI’s gpt-6.1-sol through it: a $5.00 12-hour write on $2.00 input, read at $0.10, gives h = 1.5 ÷ 2.45 = 61.2%.

Anthropic frames it sequentially, and so does most of the field: a cache “pays off after one cache read for the 5-minute duration (1.25x write), or after two cache reads for the 1-hour duration (2x write)”. That holds for a prefix written once and read k times in a row, and a per-conversation threshold built that way lands far below 21.7%. But interactive traffic isn’t that shape: requests arrive from different people at different moments, and the bill turns on the steady-state fraction landing warm.

Which is why I don’t reach for the one-hour cache on interactive traffic, or the 12-hour write. Clearing 52.6% or 61.2% warm takes traffic dense enough to keep a five-minute cache alive anyway, at 1.25x not 2x. The long lifetime might earn its multiplier where the gap between calls runs from just over five minutes to under an hour — the two lifetimes are 5 and 60 — a batch pattern rather than a conversation. I had that one-hour write at 1.5x in my head until I opened the table. It is 2x.

Cache reads are where the price really fell

Re-reading context you already sent got cheaper against base input at both vendors, ten-fold at OpenAI and four-fold across Anthropic’s ladder, and re-reading is what a loop manufactures.

Cache-read price against base input, US dollars per million, both pages read 29 October 2026.

0.50 ÷ 0.05 = 10 down the OpenAI rows and 0.1 ÷ 0.025 = 4 down the Anthropic ones. In dollars, mind, the Anthropic cache read went the other way: $0.08 on Claude Haiku 3.5, $0.25 on Claude Fable 5.1. A deeper discount is not a lower price.

Apply it to the loop. Of its 56,150 input tokens, 1,700 + 870 × 9 = 9,530 are seen once and the other 46,620 are re-reads. On Claude Opus 5.5 through the newer tokeniser, 9,530 × 1.3 = 12,389 first-seen tokens at 1.25 × $4 = $5 per million is $0.06195, 46,620 × 1.3 = 60,606 re-reads at $0.20 per million is $0.01212, and 1,924 output tokens at $20 per million are $0.03848. Total $0.11255, 8.5% under the $0.1230 single shot — but that one carried no cache_control anywhere, and the comparison is rigged unless I cache both.

So cache both. Lamplighter’s 1,600-token prefix clears Claude Opus 4.1’s 1,024-token minimum, from the Cache limitations list on Anthropic’s prompt caching page under Caching strategies and considerations. At prefix hit fraction h that call costs $0.099 fixed — 4,600 input at $15 and 400 output at $75 — plus 1,600 × [18.75(1 − h) + 1.50h] ÷ 1,000,000 (the 1.25x write and 0.1x read on $15), so $0.1290 at h = 0 and $0.1014 at h = 1. Set it equal to $0.11255: 0.129 − 0.0276h = 0.11255, h = 0.596.

Below a 59.6% prefix hit rate the cached loop is cheaper; above it the single call wins, by 11% when its prefix never misses. Lamplighter sits far below it: 43,200 minutes in a 30-day month ÷ 1,000 contracts is one call every 43 minutes, nowhere near a five-minute window. A chat surface with steady daytime traffic is where the price cut has already been spent.

Where the cheapest model stops being the cheapest

Just over 100,000 tokens of prompt on Claude Haiku 5.5, where input steps from $0.10 to $0.50 per million, and past 272,000 input tokens on gpt-5.5, where OpenAI’s Standard table doubles input from $5.00 to $10.00. Remember those Haiku rows: the tier that went $0.80, then $1, then $0.10 is the one that now prices by prompt length. Caching doesn’t get you under the line, because Long context pricing says a request’s prompt length “counts all of its input tokens, including cache reads and cache writes”.

OpenAI’s boundary repays thirty seconds. The footnote under its Standard table reads “Short context: ≤272K input tokens. Long context: >272K input tokens”, while the row label above it reads gpt-5.5 (<272K context length). At exactly 272,000 tokens the footnote and the label disagree about which price you pay.

Work the crossing. Feed Lamplighter whole contracts instead of clauses, say 8,000 tokens apiece, so the prompt grows 8,120 tokens a turn. Turn 10’s prompt is 1.3 × (1,700 + 9 × 8,120) = 97,214 tokens and turn 11’s is 1.3 × (1,700 + 10 × 8,120) = 107,770. Turn 11 bills its input at five times turn 10’s unit price, mid-run, on the model picked for being cheap.

Forecast the bill from the turn count, not the price list

Forecast the turn count, because a list price moves a few per cent in a year and the turn count moves quadratically. Output is priced at exactly 5x input on Claude Opus 4.1 (75/15), Claude Opus 5.5 (20/4) and Claude Sonnet 5.5 (10/2), so fold output into input at 5x: the single call is 6,200 + 5 × 400 = 8,200 effective tokens, and the loop is 435n² + 1,865n + 1,400, or 63,550 at n = 10. Divide one by the other and multiply by 0.3467.

Set that to 1 and solve. 435n² + 1,865n + 1,400 = 8,200 × 15 ÷ 5.2 = 23,654, so 435n² + 1,865n − 22,254 = 0 and n = 5.32. At five turns the loop costs 21,600 ÷ 8,200 × 0.3467 = 0.913 of the Claude Opus 4.1 bill; at six, 28,250 ÷ 8,200 × 0.3467 = 1.194. Below roughly five tool calls a loop still rides the price cut down and I don’t re-architect anything; at six the cut is gone and the turn count is the only lever.

Derate it hard. Three turns rather than ten is 3,915 + 5,595 + 1,400 = 10,910 effective tokens, 10,910 ÷ 8,200 × 0.3467 = 0.461. The decision flips: the price cut wins and the answer is 54% cheaper. Twenty turns the other way is 174,000 + 37,300 + 1,400 = 212,700, so 212,700 ÷ 8,200 × 0.3467 = 8.99 times. Doubling the turns more than tripled the bill: the n² term does the work and the linear one doesn’t.

In money, at Lamplighter’s thousand contracts a month: $0.33046 × 1,000 × 12 = $3,965.52 a year with caching off, $1,350.60 with it on, $1,476.00 for the single shot. Then add what the token table doesn’t price: $0.08 a session-hour on Claude Managed Agents, 1.1x on every category under a US-only inference_geo.

So instrument the three fields that move: cache_read_input_tokens, cache_creation_input_tokens and output_tokens_details.thinking_tokens, read over a fortnight, not a morning. A falling unit price is the wrong thing to watch, much as a language never won on syntax. Applied AI work here starts at the turn count, not a price list.