The 45% discount is in the announcement, its condition is in the migration guide

The 45% discount is in the announcement, its condition is in the migration guide

On September 1, 2026, Anthropic shipped Claude Fable 5.1 and Claude Mythos 5.1 at the same list price as the previous generation, $10 per million input tokens and $50 per million output tokens, while cutting the price of a cache read by four, from $1 to $0.25 per million. The announcement puts a number on the expected effect: around 25% off a typical workload, up to 45% off a heavy coding or agentic workload. The method sits in a footnote, and it is more honest than the sector average: indexed cost of the same workloads run on Fable 5 and then on Fable 5.1, at usage-based pricing, at default effort, measured over four weeks of actual usage in August 2026. VentureBeat carried both figures on launch day, and the product documentation confirms them line by line.

Faced with a discount that size, the reflex is to change the model ID and wait for the next invoice. The published prices say something else, and the arithmetic is within reach of any platform owner. A cache write costs $12.50 per million on a five-minute window, a quarter more than fresh input. As long as a read cost $1, a write cost twelve and a half reads. At $0.25, it costs fifty. The cut did not only reduce the cost of carrying context from one turn to the next, it quadrupled the gap between an architecture that keeps its prefix intact and one that rewrites it every turn. The discount rewards a discipline, not a version bump.

That discipline has a name in the documentation and three entry conditions, listed not in the announcement post but in the migration guide, where nobody goes looking for a budget argument. Forced tool use now returns an error. Earlier models can no longer read the thinking blocks Fable 5.1 produces. And any change to an earlier turn invalidates the thinking blocks that follow it. The September 1 article on the deprecation notice that became the vendor's real calendar dealt with being pushed off a version. This one deals with walking voluntarily into the next one, and with what that costs when your agent loop was written on the assumption that the history belonged to you.

Two rows of identical blocks, one traced by a thin blue reread loop, the other broken by an orange block that forces a thick return to the start.
Cache reads fell 75%. The gap between a stable prefix and a rewritten one quadrupled.

What the cache price actually changed

On most models in the family, a cache read costs a tenth of the base input price. On Fable 5.1 it costs a fortieth, 0.025 times base per the product documentation. That ratio, not the discount percentage, is what changed. Carrying a hundred thousand tokens of context from one turn to the next cost a dollar per hundred calls; it now costs twenty-five cents. On a two-hour agent session that rereads its prefix at every tool turn, the gap shows up in the usage report before it shows up on the invoice.

The rest of the grid did not move, and that is where the game is played. Writes stay at $12.50 per million for five-minute retention and $20 for an hour. The minimum cacheable prompt stays at 512 tokens. The context window is one million tokens, at standard pricing across the whole span, with 128k tokens of maximum output. None of that is new. What is new is the relative weight of a mistake: every time your prefix changes, you do not merely forfeit the discount, you pay a $12.50 rewrite where a reread would have cost $0.25. For that segment, the bill lands 25% above what the same call would have cost with no caching at all.

The words of prompt caching

Prefix: the part of a request that precedes the cache point, meaning the system prompt, the tools array and every earlier message. The cache is keyed on the bytes of that prefix: a single changed character sends it back to zero.

Cache write: the first pass of a prefix, billed above fresh input because it stores the intermediate computation. On Fable 5.1, $12.50 per million for five minutes of retention, $20 for an hour.

Cache read: reuse of a prefix already written and still valid. $0.25 per million on Fable 5.1, against $1 on Fable 5.

Append-only: a writing discipline where you add turns at the end of the history and never touch what precedes them. It is the only shape of history whose prefix stays valid from one call to the next.

The other thing worth keeping from that method note is default effort. The 25% and the 45% were measured at default effort, which is the high level on this model. If your calls run at a lower effort, your mix of reasoning tokens and reused context tokens is not the one that was measured, and neither is your saving. The reverse holds too: a setup that produces a lot of reasoning and reuses little context will watch the discount go by without touching it, since it applies to rereading, not to producing.

Three changes that invalidate common patterns

The first is clean and shows up within a day of testing. Forced tool use is no longer supported: tool_choice as {"type": "any"} or {"type": "tool", "name": "..."} returns a 400 with an invalid_request_error, on the Messages API, on the Message Batches API and on the token counting endpoint. Only auto and none remain. For teams that obtained structured output by forcing an extraction tool, the replacement path is documented: an explicit instruction in the user turn, tools declared in strict mode, or a move to structured outputs. That is not one line of code, it is a prompt rewrite plus a fresh evaluation run on every chain concerned.

The second is asymmetric, and the asymmetry is the problem. Fable 5.1 reads thinking blocks produced by Mythos 5.1, by Opus 5, by Fable 5 and by earlier generations. None of those models reads the blocks it produces. When a conversation switches from Fable 5.1 to an older model, through a router, a retry or a capacity fallback, the thinking blocks are silently removed before the older model sees them. Dropped tokens are not billed, which is correct, but nothing in the calling code signals that the conversation lost its reasoning continuity. Any multi-model fallback architecture therefore inherits an invisible degraded mode whose symptom is a weaker answer with no error message.

The third moves the decision from code level to architecture level. Since Fable 5.1, every thinking block carries a cryptographic signature encoding the producing model and the conversation prefix at the time it was produced, meaning the system prompt, the tools array and every earlier message. The API checks that signature on each call. If the prefix changed, the request comes back 400 naming the first failing block, or drops the affected blocks if you explicitly asked for that. The documentation is precise about the checked scope: top-level system prompt, tools array, earlier messages. Effort, max tokens, tool_choice, metadata and cache markers are outside it and can move freely.

What a thinking block's binding checks

Thinking block: a trace of intermediate computation returned by the model that you pass back in the history on the next turn so it does not start over. On Fable 5.1 its readable content is omitted by default.

Block binding: the signature each block carries, encoding the producing model and the exact prefix that preceded it. It checks two things, that the current model is allowed to read this block, and that nothing moved before it.

prefix_mismatch_behavior: a two-value setting behind a beta header. At `error`, the call fails 400 on the first failing block. At `drop_block`, the call succeeds, the failing block and every later one are removed, not billed, and listed in the response's `input_transformations` array.

One calendar detail changes how all of the above reads. Enforcement of the prefix check is mandatory for accounts created on or after August 31, 2026 at midnight UTC. For older accounts the check runs but does not block: mismatched blocks still reach the model unless the request explicitly opts into enforcement. Secondary coverage of the launch does not mention that distinction, and it decides whether you meet the subject as a 400 in production or as a quiet quality drift on a bill that fails to fall.

The context prefix is no longer an implementation detail

The list of moves that break a prefix deserves to be read by whoever wrote your agent loop, not by whoever negotiates the contract. Editing, reordering or removing an earlier turn breaks it. Deleting old tool results to make room breaks it. Snipping a turn out of the middle of the transcript breaks it. Client-side compaction that replaces old turns with a summary while keeping recent turns verbatim breaks it, including when it runs in the background. Rebuilding the top-level system prompt between requests breaks it. Rebuilding the tools array between requests breaks it. Injecting content you do not persist, a reminder appended then removed on the next turn, breaks it. And an image or document served by a URL that returns different bytes on the second call breaks it too.

In the field it is almost never compaction that gets caught first, because compaction is known, documented and watched. What gets caught is a system prompt line rendered from a template that injects today's date, the time, the user's name or a session ID. The prefix bytes change on every request, the cache never serves, and the usage report shows nothing but writes. In mature deployments that line often survives for months, because it never produced an error and the cost of the missed cache was buried. At a fortieth of base input for a read, it becomes the most expensive line in your prompt.

The moves that preserve the prefix are documented with the same precision, and that is the good news in the file. A strictly additive history, where you pass earlier turns exactly as they were sent and received, stays valid. Removing thinking blocks oldest first, or removing all of them, stays valid, whereas removing one from the middle leaves a gap that breaks. Moving or adding cache markers stays valid. Changing effort between requests stays valid, and with per-message effort it can now vary mid-conversation without invalidating the cache. Server-side compaction and context editing never invalidate thinking blocks, unlike their client-side equivalent.

For the three needs that pushed teams to rewrite the history, there is now a native counterpart. A mid-session instruction change goes through a system-role message appended to the messages array, instead of a rebuild of the top-level system prompt. A reminder valid for a single turn goes through a turn-scoped system message with clear_at set to next_user_message: the message stops rendering as soon as a later user turn exists, costs no more tokens, and stays physically in the array, which preserves the structure the signatures expect. A tooling change goes through tool addition and tool removal blocks, or a tool defined mid-conversation, instead of a rewrite of the tools array. Each of those three paths sits behind a dated beta header, which is scheduling information as much as code information.

Two-column diagram separating the three elements whose modification breaks the cache from the four parameters that can move freely.
The same edits break the cache and the thinking blocks. The checked boundary comes down to three elements.

What the discount assumes beyond the code

Two conditions have nothing to do with your prompt patterns and can still stop a regulated file dead. Fable 5.1 and Mythos 5.1 are designated Covered Models and require 30-day data retention. Zero data retention is therefore unavailable on these models without express authorization from Anthropic, and a request from an organization or workspace that has not enabled retention comes back 400. This is not new to 5.1, since Fable 5 and Mythos 5 already carried the same designation, and the documentation describes a per-workspace workaround: enable 30-day retention on one workspace while keeping zero retention elsewhere. But if your compliance file was built on a model that is not covered, the 45% discount is not addressed to you until that point is reopened.

Access itself is not symmetric between the two models announced together. Fable 5.1 is available to all customers, on the direct API and on the three large clouds. Mythos 5.1 is restricted to participants in a vetted access program. An announcement naming two models therefore opens one purchase path out of two, and that is the kind of detail that gets lost between reading a post and writing an internal note.

Market context adds a pressure this technical file does not create but illustrates well. On September 6, 2026, CNBC gave a name to what buyers are living through at this cadence, model fatigue, after a week in which four frontier labs shipped within days of each other. The practical consequence is less about picking a model than about repeating the exercise: if every minor version carries API-level breaking changes, migration cost becomes a recurring line rather than a one-off investment. That is the strongest argument for an execution layer that assumes nothing about the vendor, and the best test of that layer is exactly this one: how many files do you have to open to remove a forced tool_choice and make your history additive.

What to set in motion this week

Run a search for tool_choice across your repositories and count the occurrences set to any and to tool. Each one is a guaranteed 400 the day you change the model ID, and each one needs a prompt rewrite plus an evaluation, not a string replacement. That count is the only credible number for your migration cost, and it takes half a day.

Instrument before you budget, using a window that will not stay open. If your account was created before August 31, 2026, add the binding-controls beta header and read the input_transformations array on every staging response. Entries of type thinking_mismatch_allowed tell you exactly how many of your requests would have failed under mandatory enforcement, on real traffic, without breaking anything. It is a free audit of your history-mutation patterns, and it gives you the share of the discount your architecture can actually collect.

Review every place where your system prompt and your tools array are rendered from a template. Look for timestamps, user names, session IDs and counters injected into a prefix that is supposed to stay stable. Move each of them into the most recent turn, and replace your per-turn reminders with turn-scoped system messages. Measure the cache read rate before and after on the same workload: that is the only evidence that holds up in front of a committee.

Take your client-side compaction and ask the question openly: can you replace it with server-side context editing, which does not invalidate thinking blocks. If the answer is no for reasons of control or portability, write that down, price the lost cache with the token counting endpoint, and carry the cost as a documented architecture choice rather than an end-of-month surprise.

Finally, put the retention question to your compliance owner before you plan the switch, not after. The useful answer is not yes or no across the whole organization, it is whether a dedicated workspace with 30-day retention is acceptable for the scope you want to migrate first.

Conclusion

The September 1 release will be remembered as a price cut, and it is one: cache reads genuinely lost 75% of their cost, and the 25% to 45% saving rests on a measurement whose method is published. What the same documentation says with less emphasis is that the saving is earned on rereading an intact prefix, and that an agent loop rewriting its history every turn now pays a write where it could have paid a fiftieth. Context prefix stability has stopped being an optimization and become an architectural property, with a server-side check that verifies it and an enforcement date already past for recent accounts. The work is not choosing between the two model versions, it is knowing, with a number in hand, how much of the discount your code can collect.


Sources: As of September 2026