Anthropic released Claude Fable 5.2 on November 9, 2026, and for most teams on Fable 5.1 the switch is a model string and a smaller bill. Fable 5.2 costs 20% less per token than Fable 5.1, but code that edits the system prompt, the tools or an earlier message now gets a 400, so fix the history first. We cover the price, the prefix check and what drop_block costs, the three other breaking changes, the defaults that move from Opus 5.5, and how we budget a model that starts its own subagents.
Fable 5.2 is 20% cheaper per token, on the same tokenizer
The pricing page puts Fable 5.2 at $8 per million input tokens and $40 per million output, against $10 and $50 for Fable 5.1. Every other line drops by the same fifth: cache reads go from $0.25 to $0.20, batch from $5 and $25 to $4 and $20. Anthropic’s token counting guide says Fable 5.2 and Fable 5.1 “share the tokenizer introduced with Claude Opus 4.7”, so a prompt counts the same number of tokens on both. So per-token prices compare directly, which was not true for the Haiku 5.5 switch, where the tokenizer handed part of the discount back.
| Model | Input | Cache reads | Output | Batch in / out |
|---|---|---|---|---|
| Claude Fable 5.2 | $8 | $0.20 | $40 | $4 / $20 |
| Claude Fable 5.1 | $10 | $0.25 | $50 | $5 / $25 |
| Claude Opus 5.5 | $4 | $0.20 | $20 | $2 / $10 |
Prices are per million tokens. The launch announcement adds that the 5.2 models generate output up to 30% faster than Fable 5.1. Opus 5.5 is still half the price on input and output, which matters for routing.
Anthropic’s what’s new page lists four changes from Fable 5.1 that can break your code. A failed prefix check now returns a 400. Fable 5.2 thinking blocks can be read only by Fable 5.2 and Mythos 5.2. The older computer_20251124 tool returns an error everywhere except Amazon Bedrock. And with the advisor tool, a Fable 5.2 executor needs a Fable 5.2 or Mythos 5.2 advisor. The migration guide calls the rest “mostly drop-in”: always-on adaptive thinking, the forced tool choice restriction and the 30-day retention requirement all match Fable 5.1.
Any edit before a thinking block now returns a 400
Each thinking block is valid only against the system prompt, the tools and the messages that came before it. Fable 5.1 returned an error for a mismatch by default only on accounts created on or after August 31, 2026; according to the release notes, Fable 5.2 enforces the check on every account, whatever its age. The error reads The block is bound to a different conversation, and retrying the same body fails the same way.
The prefix check reference is strict about what counts: “A change can be as small as one word of a tool description.” Changing, inserting, moving or deleting an earlier message counts, whatever its role. Parameters do not: model, effort, max_tokens and tool_choice sit outside the comparison, and so do cache_control markers and JSON key order. Context compaction at a token threshold and context editing never count either, because they change what Claude reads rather than what you sent.
That leaves the client-side patterns we see most in agent code: trimming old turns to stay under a budget, rewriting the system prompt with fresh state on every turn, redacting a tool result after the fact, and an MCP server whose tool list changes between requests. The migration guide flags that last one: for Fable 5.2 thinking blocks, a tool list that changes between requests counts as an edit, while for Fable 5.1 blocks it does not. If Claude Code, the Claude Agent SDK or Managed Agents builds your requests, nothing changes. If your own agent harness builds them, it has to be append-only.
The test Anthropic recommends is a session with the binding beta and drop_block, so every invalid block is listed instead of the first one stopping the run. Run it against the model you use now, Fable 5.1 or Opus 5.5, and against claude-fable-5-2 as well if an MCP server’s tool list is not pinned.
resp = client.beta.messages.create(
model="claude-fable-5-1", # the model you run today
max_tokens=16000,
thinking={
"type": "adaptive",
"block_binding": {"prefix_mismatch_behavior": "drop_block"},
},
betas=["thinking-binding-controls-2026-08-01"],
messages=messages,
)
for entry in resp.input_transformations or []:
if entry.type == "thinking_dropped":
print(entry.path, entry.reason)
Change something on purpose first, so you have seen the test fail. Then run real sessions that compact, add tools late, resume or switch models, because a session of plain turns never exercises the code that edits history.
drop_block keeps the conversation alive and costs you the cache
drop_block is the stopgap. The API drops the affected blocks, the request succeeds, and input_transformations lists what went. Anthropic is direct about the price in its guide to the error: Claude can spend more output tokens rebuilding reasoning it can no longer read, and “Dropping the blocks also invalidates the prompt cache from the first dropped block onward.”
That second half is where the 20% saving can disappear. Take one agent turn with a 400,000-token prompt, 90% of it cached, and 30,000 output tokens. On Fable 5.2 that turn costs 40,000 × $8 + 360,000 × $0.20 + 30,000 × $40 per million, which is $0.32 + $0.07 + $1.20, or about $1.59, against $1.99 on Fable 5.1. If a dropped block sits near the top of that prefix, the 360,000 cached tokens are written again at the 5-minute rate of $10 per million: $3.60 instead of $0.07. That one turn adds about $3.53, nearly nine times the $0.40 the price cut saved on it, and code that edits on every turn pays it on every turn. Prompt caching only works on a prefix that stays put; we wrote up the same lesson for LangChain prompt caching in production.
The rule: in production, leave
prefix_mismatch_behaviorat its default,"error". A loud 400 in your logs is cheaper than a quiet cache miss on every turn.
Thinking blocks only travel between Fable 5.2 and Mythos 5.2
On the Claude API and on Google Cloud (Google managed), Fable 5.2 reads thinking blocks from older models: Opus 5.5, Sonnet 5.5, Haiku 5.5, Fable 5.1, Mythos 5.1, Opus 5, Fable 5 and Mythos 5. The what’s new page is just as clear about the other direction: “No other model reads their blocks.” When a request carries a block the current model cannot read, the API drops it, the request succeeds and the dropped block is not billed.
For model routing, that turns a fallback into a quiet downgrade. A conversation that starts on Fable 5.2 and moves to Opus 5.5 for cheap turns, or to Fable 5.2’s own server-side fallback targets (Opus 4.8 and Opus 5), loses all the reasoning from the Fable turns, with no error to tell you. Route at task boundaries instead.
Computer use and the advisor tool need new definitions
Computer use moves to the computer_toolset_20260801 toolset. Declaring computer_20251124 returns a 400 invalid_request_error on every platform except Bedrock. The computer use docs list nine migration steps, and four of them change your agent loop or its handlers, such as iterating over every tool_use block in a response rather than the first and adding "toolset_name": "computer" to each result. The toolset also rejects an oversized screenshot instead of downscaling it.
The advisor tool, still in beta, requires an advisor at least as capable as the executor. A Fable 5.2 executor accepts only Fable 5.2 or Mythos 5.2; a Fable 5.1 advisor now returns a 400. If you run an advisor agent pattern, change the advisor model in the same deploy as the executor, and only for new conversations, because the advisor’s model lives in tools and changing it mid-conversation fails the prefix check above.
Coming from Opus 5.5, the defaults move too
From Fable 5.1, the migration stops at the four breaking changes above. From Opus 5.5 the guide lists more, and the quiet one is effort. The effort guide sets Fable 5.2’s API default to high, while Opus 5.5 defaults to medium, so a request that never sets reasoning effort runs a level higher and costs more without any error. We compared how each vendor handles this in reasoning effort across OpenAI, Claude and Gemini. Pin effort per task and re-run the sweep.
Two can stop requests outright. Fable 5.2 needs 30-day data retention, so under a zero data retention arrangement every request returns a 400 until you enable retention for the workspace. And in an organization with customer-managed encryption keys, Opus 5.5 supports structured output while Fable 5.2 does not. Adaptive thinking and the 400 for a forced tool_choice carry over unchanged, since Opus 5.5 already works that way.
Two smaller ones belong in the same checklist. Thinking tokens count toward max_tokens, so a small max_tokens can stop after a thinking block with no text. And Fable 5.2’s rate limit is separate from Opus 5.5’s, with lower token limits at each tier per the guide; the rate limits page also takes it out of the combined Fable 5.1 and Fable 5 bucket, so LLM rate limiting tuned for either model needs a second look.
How we keep a model that starts its own subagents on a budget
Fable 5.2 can start subagents on its own, and nothing errors when it does. The migration guide reports that at xhigh and max, in an agentic coding product, Anthropic saw Fable 5.2 start subagents to review its own work, which Fable 5.1 did not do on the same tasks. More subagents means more tokens per task, and a 20% lower price per token does not cover a task that spends twice as many.
Our own scheduled agents, including the one that researches, drafts and reviews posts on this blog, already run every subagent under a wall-clock ceiling, 30 minutes unless the job sets another, and a subagent that passes it is stopped and replaced once, never waited on. We track cost per task for the same reason: a cheaper token is only a saving if the task count stays put. Our agents run inside Claude Code, so the prefix check is Claude Code’s problem rather than ours; the subagent budget is not.
Where Fable 5.2 belongs in a routing table
Anthropic’s own advice has not changed with the price: the announcement recommends users “start with Claude Opus 5.5, our strongest daily driver”, and move up to Fable for the most demanding work. Its own benchmark shows the gap between the two narrowing. On its FrontierCode 2.0 evaluation, Fable 5.2 at high scored 45.3% against Opus 5.5’s best of 45.5%, for roughly half the cost per task. That is a vendor benchmark on one evaluation, so treat it as a reason to run your own AI agent evals on Fable 5.2 at high. For reasoning models priced this far apart, let those evals set the routing.
The takeaway
Fable 5.2 is a straight 20% price cut on the same tokenizer, and for code built by Claude Code or the Agent SDK it is close to a drop-in. For code that builds its own requests, the prefix check is the whole migration: make the history append-only, test with drop_block once to find every edit, then run production on the default error setting. Move computer use to the toolset, pair the advisor in the same deploy, and if you come from Opus 5.5, pin effort before the high default reaches your bill. Then compare cost per task, the way we did for programmatic tool calling on Claude.
Sources
- Claude Developer Platform release notes, Anthropic
- Introducing Claude Fable 5.2 and Claude Mythos 5.2, Anthropic, November 9, 2026
- What’s new in Claude Fable 5.2, Anthropic docs
- Migrating to Claude Fable 5.2, Anthropic docs
- Pricing, Anthropic docs
- Token counting, Anthropic docs
- Prefix checks, Anthropic docs
- Fix “bound to a different conversation”, Anthropic docs
- Computer use tool, Anthropic docs
- Advisor tool, Anthropic docs
- Effort, Anthropic docs
- Rate limits, Anthropic docs