Which Cut Was Yours?

TL;DR.

Max Woolf's post from yesterday, "OpenAI and Anthropic cut their LLM prices by up to 80% within a few months. Why?", lists every price change the two labs made between June and the end of September. It's the best single timeline of 2026's price war, and its question is a good one. This post asks a narrower one: which of those cuts lowered your bill?

• "Up to 80%" is one model. The 80% figure is GPT-5.6 Luna on July 30. Every other cut on the list is smaller, and four of them touched only one line of the rate card.
• Most of the cuts that mattered to agents were cache-read cuts. Fable 5.1 (September 1), GPT-6.1 Sol (September 29) and Sonnet 5.5 (October 7) left input and output prices alone and cut cached input. In our model, those three cut a coding-agent request by 52%, 36% and 35%. They cut a plain chat request by 0%.
• 98% of an agent's tokens are cache reads, but only 54% of its bill. Woolf says cache reads are "the vast majority (96% - 99%)" of his token expenditure. By token count we get the same, 97.9%. By dollars on Sonnet 5.5 it's 53.7%, because cache writes and output are priced 25x and 100x higher.
• The cuts re-sorted the model ladder by workload. Fable 5.1 and GPT-6 Astra cost the same per chat request and 2x apart per agent request. DeepSeek V4.1 Flash is the third-cheapest model for chat in our set and the cheapest for agents.
• Below is whichcut.py, 70 lines that read your usage export, report your token mix, price it at each old and new rate card, and rank the models for your traffic, not an average one.

Price history is from Woolf's post and provider pricing pages, at list prices as of October 26, 2026. The three request shapes are ours and are illustrations, not measurements. No figure here comes from Nadir customer data.

The timeline.

Woolf's table covers twelve changes in fourteen weeks. Here are the ones that cut a price on a model you could already buy, plus the Sonnet 5.5 cache cut that came after his window. Prices are per million tokens: input / output / cache read.

Read the last column. Half of these changes didn't move the input or output price at all. If you compare models by the two numbers every pricing table leads with, three of the seven cuts are invisible. We made the same point about one pair of models in Same Sticker, Different Bill. Across the whole timeline, it's the rule, not the exception.

Three bills, one cut.

A rate card has four lines: uncached input, cache write, cache read and output. Which cut you got depends on how your requests split across them. We priced three common shapes:

• Coding agent. 90,000 cache-read tokens of history, 1,500 new tokens written to cache, 400 output tokens. A mid-session agent turn.
• Chat. 4,000 uncached input tokens, 400 output tokens. A RAG answer or support reply with nothing cached.
• Classifier. A 1,200-token cached instruction prefix, 300 new tokens, 20 output tokens. Tagging, routing or extraction at volume.

Anthropic bills cache writes at 1.25x input. OpenAI, Moonshot and DeepSeek bill them at the input rate.

Three things follow.

The labs aimed the cuts at agents. Every Anthropic cut in the window was bigger on the cache-read line than anywhere else. If your traffic is a coding agent with a long cached prefix, your Fable bill halved on September 1 without a single headline saying so. If your traffic is uncached chat, nothing happened.

The Opus 5.5 cut is two cuts. For chat it's the 20% everyone reported. For an agent it's 48%, because the cache read fell 60% while input and output fell 20%. Teams that priced Opus 5.5 off the headline underestimated how much cheaper their agents got.

The Sol line compounds. From GPT-5.6 Sol in June to GPT-6.1 Sol today, an agent request on our shape fell 75.2%, which matches Woolf's "cumulatively 75% cheaper." A chat request fell 62.5%. Same model family, a 13-point difference set by the shape of the request.

98% of the tokens, 54% of the bill.

Woolf writes that cache reads are "the vast majority (96% - 99%) of the total token expenditure." That's right by token count, and it's worth being careful about what it implies for dollars.

On Sonnet 5.5, our agent request is 97.9% cache-read tokens. Those tokens cost $0.10 per million, while cache writes cost $2.50 and output $10. So the dollars split 53.7% cache read, 22.4% cache write and 23.9% output. A 1.6% sliver of tokens carries more than a fifth of the bill.

This is why a cache-read cut lowers an agent's bill by a third to a half, not by 98% of the cut. It's also why the last few hundred output tokens and the cache writes matter more than their token counts suggest. We covered what breaks a cached prefix and bills it as a write in the compaction tax and Watch the Wire. After this round of cuts, a cache miss is relatively more expensive than it was in June, because reads got cheaper and writes didn't.

The ladder re-sorted.

Cuts that move one line of a rate card don't just lower prices. They change which model is cheapest for which job. Here are nine models at October 26 list prices, on the chat and agent shapes, per 1,000 requests.

Three rankings flip between the two columns:

• Fable 5.1 vs Astra. Tied on chat at $60. On the agent shape Astra costs 2x, entirely because of the $1.00 vs $0.25 cache read.
• Kimi K3.1 Pro vs Sonnet 5.5 and Sol. Woolf points out that Kimi K3.1 Pro scores 55 on the Artificial Analysis index to Opus 5.5's 58 at half Opus's input and output price. On chat it ties Sonnet 5.5 and GPT-6.1 Sol. On the agent shape it costs 49% more than Sonnet, because its cache read is still $0.20.
• DeepSeek V4.1 Flash vs Haiku 5.5 and Luna. It's 40% more expensive per chat request and 43% cheaper per agent request, because its cache read is $0.003.

None of this says which model to use. Price per request is half the decision. The other half is whether the cheaper model finishes the task, which we measured for three of these models in Three at $2/$10, and why the model with the lower price sometimes costs more is in the price reversal. What it does say: a model choice made in June on June's rate cards is probably wrong now, and whether it's wrong depends on your token mix.

Why the gap matters more than the cut.

Woolf's conclusion is that "the idea that token prices will suddenly rise is more a fantasy," with open-weight models and secondary providers acting as "an economic check on the prices." We agree, and it's the reason routing matters more after the cuts, not less.

Every tier got cheaper, but the distance between tiers didn't close. On the chat shape, Fable 5.1 still costs 100x Haiku 5.5. On the agent shape it's 47x. A request sent to the frontier tier that the bottom tier could have finished is still a 50x to 100x overpayment. The cuts lowered the floor of the bill. The ratio between what you pay and what you needed to pay is the same.

Cheap Tokens, Empty Budgets found the same thing from the other side: one in three large firms had already exhausted its annual token budget in a year when price per token fell, with an estimated 54% of requests going to a needlessly expensive tier.

Tutorial: whichcut.py.

whichcut.py answers the question in the title for your own traffic. It reads a usage export with one row per request, computes your average mix across the four rate-card lines, and prints three things: the mix, what each cut did to a bill with that mix, and the models ranked by cost per 1,000 requests.

Most provider and gateway exports carry these four counts under different names. Anthropic reports cache_read_input_tokens and cache_creation_input_tokens separately from input_tokens. OpenAI reports cached_tokens inside prompt_tokens_details, as part of prompt_tokens, so subtract it to get uncached input. Rename the columns to model, input, cache_write, cache_read, output, with input meaning uncached input.

"""whichcut.py: price your own token mix at old and new rate cards.

Reads a usage export (CSV) with one row per request and the columns
model, input, cache_write, cache_read, output (token counts, where input
means uncached input). Prints your token mix, what each 2026 price cut did
to a bill with that mix, and how candidate models rank on it.
"""
import csv
import sys

# USD per million tokens: input, cache write, cache read, output.
# List prices as of October 26, 2026. Check them before you rely on them.
CARDS = {
    "fable-5": (10.00, 12.50, 1.00, 50.00),
    "fable-5.1": (10.00, 12.50, 0.25, 50.00),
    "opus-5": (5.00, 6.25, 0.50, 25.00),
    "opus-5.5": (4.00, 5.00, 0.20, 20.00),
    "sonnet-5.5-launch": (2.00, 2.50, 0.20, 10.00),
    "sonnet-5.5": (2.00, 2.50, 0.10, 10.00),
    "haiku-5.5": (0.10, 0.125, 0.01, 0.50),
    "gpt-5.6-sol-june": (5.00, 5.00, 0.50, 30.00),
    "gpt-6.1-sol": (2.00, 2.00, 0.10, 10.00),
    "gpt-6-luna": (0.10, 0.10, 0.01, 0.50),
    "gpt-6-astra": (10.00, 10.00, 1.00, 50.00),
    "deepseek-v4.1-flash": (0.15, 0.15, 0.003, 0.60),
}
CUTS = [("fable-5", "fable-5.1"), ("opus-5", "opus-5.5"),
        ("sonnet-5.5-launch", "sonnet-5.5"), ("gpt-5.6-sol-june", "gpt-6.1-sol")]
FIELDS = ("input", "cache_write", "cache_read", "output")


def load_mix(path):
    """Average tokens per request, by bucket, over the whole file."""
    totals, n = [0, 0, 0, 0], 0
    with open(path, newline="") as f:
        for row in csv.DictReader(f):
            for i, k in enumerate(FIELDS):
                totals[i] += int(row[k] or 0)
            n += 1
    return [t / n for t in totals], n


def cost(card, mix):
    """Dollars per request for this mix at this rate card."""
    return sum(p * t for p, t in zip(CARDS[card], mix)) / 1e6


def main(path):
    mix, n = load_mix(path)
    total = sum(mix)
    print(f"{n} requests, {total:,.0f} tokens per request on average")
    for k, t in zip(FIELDS, mix):
        print(f"  {k:<12}{t / total:6.1%}")

    print("\nWhat each cut did to a bill with your mix:")
    for old, new in CUTS:
        change = cost(new, mix) / cost(old, mix) - 1
        print(f"  {old:>18} -> {new:<12}{change:+7.1%}")

    print("\nCost per 1,000 requests with your mix, cheapest first:")
    retired = {o for o, _ in CUTS}
    ranked = sorted((c for c in CARDS if c not in retired),
                    key=lambda c: cost(c, mix))
    floor = cost(ranked[0], mix)
    for c in ranked:
        print(f"  {c:<22}${cost(c, mix) * 1000:9.3f}  {cost(c, mix) / floor:6.1f}x")


if __name__ == "__main__":
    main(sys.argv[1])

Run it on a sample of a few thousand requests. On a synthetic 500-request coding-agent log, it prints:

500 requests, 91,315 tokens per request on average
  input         0.0%
  cache_write   1.6%
  cache_read   97.9%
  output        0.4%

What each cut did to a bill with your mix:
             fable-5 -> fable-5.1    -52.6%
              opus-5 -> opus-5.5     -48.0%
   sonnet-5.5-launch -> sonnet-5.5   -35.0%
    gpt-5.6-sol-june -> gpt-6.1-sol  -75.2%

Cost per 1,000 requests with your mix, cheapest first:
  deepseek-v4.1-flash   $    0.727     1.0x
  gpt-6-luna            $    1.239     1.7x
  haiku-5.5             $    1.276     1.8x
  gpt-6.1-sol           $   15.840    21.8x
  sonnet-5.5            $   16.584    22.8x
  opus-5.5              $   33.167    45.6x
  fable-5.1             $   60.559    83.3x
  gpt-6-astra           $  123.915   170.5x

Three ways to use the output:

1. Re-check last quarter's model choice. If the model you picked in June isn't near the top of your ranking now, price the switch, then test whether the cheaper model finishes your tasks before you move.
2. Split by workload before you average. Run it once per use case, not once for the company. An agent mix and a chat mix give different rankings, so one company-wide default is wrong for at least one of them.
3. Watch the cache-write line. If cache_write is more than a few percent of tokens, your prefix is breaking. After the cuts, that's the line where an agent's money goes.

Keep CARDS current. Seven cuts in ten weeks means a price table older than a month is probably out of date.

Where Nadir fits.

whichcut.py prices your mix once. A router has to make the same decision on every request, with the current rate cards.

Routing picks the tier per request. With model="auto", Nadir sends each request to the cheapest model in your configured set that clears your quality floor. The ladder above is the reason: the cuts made every tier cheaper but left a 50x to 100x gap between the bottom and the top, and only a per-request decision closes it. A routing decision should also stick for a session rather than flip per turn, because a router that switches models mid-session pays a fresh cache write each time, as covered in Your Router Is Fighting Your Prompt Cache.

Every response reports what it cost. The model that served the request and its cost come back on each response, so the mix and per-request cost in the tutorial exist for the whole team without a separate export. Tag requests with X-Nadir-Use-Case and spend is recorded per workload, which is the split the tutorial says to make.

If you'd rather measure before anything changes, Observe mode serves exactly the model you asked for and records what routing would have chosen. With your own provider keys, Nadir charges no fee on any plan, and the provider bills you directly. Savings depend on your workload, and nothing in this post forecasts yours.

Start with a free key, and run whichcut.py on a week of your traffic first.

Conclusion.

The 2026 price cuts were real, and most of them were aimed at agents. Four of the seven cuts here cut cached input more than anything else, and three cut nothing else. A coding agent on Fable, Opus, Sol or Sonnet got a 35% to 75% cheaper request. A chat workload on the same models got between nothing and 62%. The cuts also re-sorted the model ladder, so the cheapest model for your agent may not be the cheapest for your chat. What the cuts didn't do is close the gap between tiers. Price your own mix, rank the models on it, and route the requests that don't need the top tier away from it.

Price history is from Max Woolf's post and the providers' pricing pages. The Sonnet 5.5 cache cut on October 7 is after Woolf's window and comes from Anthropic's pricing page, as covered in [our Haiku 5.5 post](/blog/claude-haiku-5-5-pricing-100k-cliff-tokenizer-effort). Haiku 5.5 is priced at its rate for prompts up to 100K tokens. Kimi K3.1 Pro and DeepSeek V4.1 Flash prices are as Woolf lists them, with cache writes assumed to bill at the input rate. The three request shapes, the per-request costs and the synthetic usage log are ours, and are illustrations, not measurements. Prices change often: check the current pricing pages before you rely on any figure here. Sources: [Max Woolf, "OpenAI and Anthropic cut their LLM prices by up to 80% within a few months. Why?", October 25, 2026](https://minimaxir.com/2026/10/cheap-llms/). [Anthropic, Pricing](https://www.anthropic.com/pricing). [Anthropic, Prompt caching](https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching). [OpenAI, API pricing](https://openai.com/api/pricing/). [OpenAI, Prompt caching](https://platform.openai.com/docs/guides/prompt-caching). [DeepSeek, Models and pricing](https://api-docs.deepseek.com/quick_start/pricing).