2026.09.21 2026.09.21

What Changed in Claude Fable 5.1 — Two Names, One Model, and a Cache Read at a Quarter of the Price

swiftwand

On September 1, 2026, Anthropic released Claude Fable 5.1 and Claude Mythos 5.1. Anyone following the announcement runs into the same two puzzles. Two names sit side by side, and the vendor says they are the same model. Open the price table and input and output are unchanged; exactly one row moved.

This article starts from that one row. Cache reads now cost a quarter of what they did, and that is not a story about intelligence. It is a story about whether it pays to leave a model running for hours.

Every figure below was taken on September 17, 2026 from the announcement, the model page, and the migration guide. No numbers come from secondhand summaries, and the reason for that shows up later in the piece.

Why this is not just another model release
Two names, one model
What the specification pins down
Only one row moved in the price table
What a cache read actually is
The reversal against Opus 5
Behavior that changed quietly from Fable 5
Breaking changes, and who they reach
Five additions
Three things to check before switching in Claude Code
What it means at the 3D printing bench
The short version
Sources

忍者AdMax

Why this is not just another model release

Models ship several times a year. What is worth noticing here is which direction the improvement points. The vendor leads with long-running agentic work, multistep research, and producing documents, spreadsheets, and slides. None of those are one-question-one-answer tasks. They are all about getting work done while you are away from the screen.

That direction changes the shape of the bill. For a single question, input and output rates are all you need to watch. But an agent running for hours re-reads the same preamble hundreds of times: the system prompt, the tool definitions, the conversation so far. The cost of re-reading starts to dominate. The one row that moved in Fable 5.1 is exactly that rate.

Two names, one model

The announcement is unambiguous: Claude Fable 5.1 and Claude Mythos 5.1 are the same model, and the only difference is the stage of safeguards applied. The model page adds that Mythos 5.1 shares specifications and pricing with Fable 5.1 and is offered by invitation, to participants in Anthropic Project Glasswing.

Practically, that means benchmark numbers and behavior notes published for one apply to the other. What differs is who can reach it and under what safety posture.

What the specification pins down

Item	Claude Fable 5.1 / Mythos 5.1
Model ID	claude-fable-5-1 (anthropic.claude-fable-5-1 on Amazon Bedrock)
Context window	1M tokens, default and maximum, priced at the standard rate across the whole range
Max output	128K tokens
Thinking	Adaptive thinking, always on. Depth is set with effort; the default is high, and all five levels are supported
Knowledge cutoff	June 2026
Input and output	Text and images in, text out
Released	September 1, 2026
Retirement	Not sooner than September 1, 2027

Only one row moved in the price table

Per million tokens	Fable 5	Fable 5.1
Input	$10.00	$10.00
Output	$50.00	$50.00
5-minute cache write	$12.50	$12.50
1-hour cache write	$20.00	$20.00
Cache read	$1.00	$0.25
Batch	50% off	50% off

Every other model in the lineup prices cache hits at 0.1x base input. Fable 5.1 and Mythos 5.1 price them at 0.025x. That is the whole change, and it is a four-fold cut on the one line that a long-running agent hits most often.

What a cache read actually is

The API matches the start of each request, the prefix, against content it processed recently. On a normal turn, the prefix is the entire previous request and only the latest exchange is new. The match is exact, so a change anywhere in the prefix recomputes everything after it. There is no per-file or per-segment caching.

A cache read is what you pay to have that unchanged prefix served back instead of reprocessed. The longer the preamble and the more turns you take, the larger the share of your bill that line represents. Cut it to a quarter and a long agent run gets meaningfully cheaper without anything else changing.

The reversal against Opus 5

Per million tokens	Claude Opus 5	Claude Fable 5.1
Input	$5.00	$10.00
Output	$25.00	$50.00
5-minute cache write	$6.25	$12.50
1-hour cache write	$10.00	$20.00
Cache read	$0.50	$0.25

Fable 5.1 is twice Opus 5 on input, output, and both cache writes, and half of it on cache reads. So the comparison flips depending on the shape of the work. Ask one question and Fable costs double. Run a loop that reads a large fixed preamble over and over, and the read line, where Fable is cheaper, grows until it dominates.

If you only ever ask one-off questions, there is no cost argument for moving to Fable 5.1. Input and output are still twice Opus 5.

Behavior that changed quietly from Fable 5

The migration guide lists differences that show up without any code change. People running long loops notice them first.

Fewer parallel tool calls. In long loops with independent reads, 5.1 may issue one tool call per turn where Fable 5 batched several. The answer quality is the same, but each extra turn costs tokens, a round trip, and wall-clock time. The vendor suggests appending a one-sentence batching instruction as a turn-scoped system message.
Fewer progress messages. Short status notes between tool calls get sparser, especially at high effort. To someone watching the screen it looks quiet. Progress text comes back as thinking blocks with display set to omitted by default; set display to updates, in beta, to get it back as text.
More answering from memory at low effort. At the lowest effort level, 5.1 calls search and retrieval tools less often than Fable 5. Raise effort for turns that need fresh information, or say explicitly when to search.
Whole-file rewrites for small edits. The result is the same, but output tokens and time go up.
Denser prose, less decoration. Paragraphs run longer and bold and headings appear less often. Instructions written for older models telling them not to decorate can now strip out structure you actually wanted.

None of these is fatal. But in unattended use they matter more than they look: turns multiply where nobody is counting, and a silent run gives you no way to tell whether it is stuck or thinking.

Breaking changes, and who they reach

There are three, and if you work through Claude Code rather than assembling message arrays yourself, two of them never surface.

Forced tool choice now errors. Setting tool_choice to any or to a named tool returns a 400 invalid_request_error. The stated reason is that forcing a call on an always-thinking model lets reasoning leak into the tool arguments and degrades quality. Use tool_choice auto plus an explicit instruction, or JSON outputs.
Older models cannot read 5.1 thinking blocks. Switch a conversation back from 5.1 to an older model and that reasoning is lost for those turns. The API drops the blocks before sending and does not bill for them. The other direction is fine, and the history itself is untouched, so the same conversation recovers the blocks when it returns to 5.1.
Editing an earlier turn invalidates thinking blocks. Rebuilding the system prompt or the tools array mid-conversation makes the next request fail or drop blocks. This check is enforced for accounts created on or after August 31, 2026 and optional for older ones, and Claude Mythos 5.1 does not run it at all.

The guide notes that Claude Code, claude.ai, Claude Managed Agents, and the Claude Agent SDK keep the conversation prefix intact for you, which is why the first and third rarely bite a Claude Code user. The second still does: switch models with /model and the turns that run on the older model cannot see what 5.1 was thinking.

The third one also connects straight back to caching. A design that never edits earlier turns protects thinking blocks and the cache prefix at the same time.

Five additions

Per-message effort, in beta: change effort mid-conversation without breaking the cache, so only the hard turns think deeply
Turn-scoped system messages, in beta: instructions that clear at the next user message
Progress updates between tool calls, in beta: the display setting that brings the status text back
The lower cache read price, at 0.025x base input
Content provenance: a statistical text watermark and C2PA Content Credentials on generated media

Three things to check before switching in Claude Code

Fable 5.1 requires Claude Code v2.1.257 or later. Run claude update if an older version rejects the model
Neither Fable model is the default on any plan or provider. Select it explicitly with /model fable or claude –model fable
Depending on your plan and seat tier, Fable usage can bill to usage credits instead of your plan allowance. The /model picker shows “Requires usage credits” on the Fable row when it does, and interactive sessions show a consent prompt before the first billed request

That last point is the one worth pausing on. A model that pays off precisely when you leave it running unattended is also the model most likely to run up metered usage while nobody is watching. Check which side of that line your plan puts you on before you wire it into anything that runs on a schedule.

What it means at the 3D printing bench

The parallel to a workshop is closer than it looks. A quoting job has a fixed preamble too: filament prices per kilogram, the electricity rate, the shipping table, the platform fee percentage. What changes per item is the gram count and the print hours. Quote a hundred parts and you write that preamble once and read it a hundred times.

That is the shape the cheaper cache read rewards. The same holds for a batch of STL files checked against the same set of tolerances, or a week of articles checked against the same review criteria. If your repeated work has a large fixed front and a small variable tail, the read line is where your money goes, and it just got cheaper.

The short version

Fable 5.1 and Mythos 5.1 are one model with two safety postures; specifications and prices are shared
Input, output, and both cache writes are unchanged. Cache reads fell from $1.00 to $0.25 per million tokens
Against Opus 5, Fable 5.1 is twice the price on input, output and writes, and half on reads, so the comparison depends entirely on how repetitive your work is
Parallel tool calls and progress messages both thin out, which matters most in runs nobody is watching
Three breaking changes exist; Claude Code shields you from two, and the third is the model switch that loses 5.1 thinking blocks
Requires Claude Code v2.1.257, is never the default, and may bill to usage credits depending on your plan