Skip to main content
Golden-hour mountain gorge with a weathered rope-and-plank footbridge beside a new timber and steel cable bridge, a metaphor for migrating from Claude Fable 5.1 to Claude Fable 5.2
9 min readBy Carlos Aragon

Claude Fable 5.2 vs Fable 5.1: Tested Speed and Cost

Claude Fable 5.2 is a cheaper, faster drop-in for Fable 5.1 as long as your code never edits conversation history: it costs $8/$40 per million tokens instead of $10/$50, and on a long answer it generated 79 tokens per second against Fable 5.1's 55. That's from 74 requests I ran this morning, the day after launch. The same requests came out 21-23% cheaper. The catch: the first token showed up later, prompt tricks that used to skip thinking stopped working, and four API changes return a 400 if you only swap the model ID.

What Changed From Claude Fable 5.1 to 5.2?

Anthropic shipped Fable 5.2 and Mythos 5.2 on November 9, 2026. Same underlying model, different safeguards: Fable is open to everyone, Mythos only to orgs in the verification programs. The launch post claims output up to 30% faster than 5.1, better coding and vision, and about 55% fewer safety classifier blocks. The specs you plan around didn't move: 1M-token context, 128K max output, always-on adaptive thinking, the same tokenizer.

The first thing I did was pull both models from /v1/modelsand diff the capability flags. They're identical. Same effort levels (low through max), same context management strategies, same thinking types (adaptive only), same server tools. So nothing in the models endpoint warns you about the breaking changes. They live in request validation, not in capability flags.

Here's the price sheet per million tokens, with Opus 5.5 for reference:

Per MTokFable 5.1Fable 5.2Opus 5.5
Input$10$8$4
Output$50$40$20
Cache read$0.25$0.20$0.20
5-min cache write$12.50$10$5
Batch (in / out)$5 / $25$4 / $20$2 / $10
Fast mode (in / out)not offered$16 / $80$8 / $40

Look at the cache read row. Fable 5.2 reads cached tokens at $0.20, the exact price Opus 5.5 charges. For an agent that re-reads a big cached context every turn, the input side of the bill is now the same on both models. The gap is in output and uncached input. I covered why those cache reads matter so much in the Fable 5.1 pricing breakdown, and it still holds.

Is Claude Fable 5.2 Actually Faster?

At writing tokens, clearly. At answering a short question, no. I asked each model for a 700-word plain-prose explanation of webhook idempotency keys at effort low, three runs each, and timestamped every streamed event:

MeasuredFable 5.1Fable 5.2Opus 5.5
Generation speed, ~1,300-token answer (median of 3)55 tok/s79 tok/s85 tok/s
Time to first text token, same task0.70 s1.03 s1.86 s
Time spent generating22.4 s15.7 s14.9 s
Thinking tokens at effort low0, 0, 045, 41, 2513, 24, 13
Short reply, API time (classify, median of 4)0.84 s0.95 s1.34 s
Cost of the same first request (classify)$0.0129$0.0100$0.0050

79 versus 55 tokens per second is a 43% jump, more than the "up to 30%" Anthropic advertises. Launch-week traffic could push that either way, so treat it as a snapshot. The 1,300-token answer finished about 6.5 seconds sooner. That's real for anything that writes reports, code files or long tool inputs.

The first token is a different story. Fable 5.2 started writing about 0.3 seconds later, and on one-word replies it was 0.08-0.19 seconds slower end to end across every task I ran. Part of that is thinking: at effort low Fable 5.2 still spent 25-45 thinking tokens before the prose, where Fable 5.1 spent zero. If you run a voice agent or anything where time to first token is the number users feel, measure before you switch. If you need raw generation speed on top of that, fast mode is now offered on Fable 5.2 at $16/$80, the same premium setup I tested on Opus 5.5 fast mode.

What Breaks When You Switch to claude-fable-5-2?

The happy path is one line:

# Python
model = "claude-fable-5-1"  # before
model = "claude-fable-5-2"  # after

# Amazon Bedrock
model = "anthropic.claude-fable-5-2"

The official migration guide lists four changes that can break your code. If Claude Code, the Agent SDK or Managed Agents build your requests, none of them touch you. If you wrote your own agent loop, read all four.

1. The prefix check now applies to every account

Every thinking block is signed against what came before it: the system prompt, the tools and the earlier messages. Change any of those and send the old block back, and the request fails with:

messages.5.content.0: Invalid `signature` in `thinking` block.
The block is bound to a different conversation. Remove the block, or set
`thinking.block_binding.prefix_mismatch_behavior` to "drop_block".

Fable 5.1 only enforced this on accounts created on or after August 31, 2026. Fable 5.2 enforces it everywhere. So an older account can run history-editing code on 5.1 for months without an error, then hit a 400 on the first 5.2 request.Retrying doesn't clear it. The usual suspects: trimming old turns to save tokens, rewriting a tool result, injecting today's date into the system prompt each turn, or an MCP connector whose tool list shifts between requests.

2. Fable 5.1 can't read Fable 5.2's thinking

Moving a conversation up from 5.1 to 5.2 keeps its reasoning. Moving it back down, or to Opus 5.5, or through a refusal fallback to Opus 4.8 or Opus 5, drops every Fable 5.2 thinking block. The request still succeeds and you aren't billed for the dropped tokens, but the model works without that context, so the first turn after the switch gets slower and pricier. Any router that downshifts to a cheaper model mid-conversation pays this tax.

3. computer_20251124 returns a 400

Outside Amazon Bedrock, declare the computer_toolset_20260801 toolset instead. If you still run the old tool, my browser use vs computer use comparison is worth a look before you port the loop.

4. The advisor must be Fable 5.2 or Mythos 5.2

A Fable 5.2 executor rejects every other advisor with a 400, Fable 5.1 included. Changing the advisor's model is itself an edit to tools, so do it in new conversations, or breaking change #1 bites you. The reverse works: any executor accepts a Fable 5.2 advisor, which is a cheap way to try the new model. I compared the advisor pattern to plain delegation in advisor tool vs subagents.

I couldn't trigger these four errors myself today. My API key is out of credit, and the API checks billing before it validates parameters, so every bad request returns the same credit error. The error text above is quoted from Anthropic's docs, not from my logs.

How Do You Find History Edits Before They Break Production?

Run your current traffic on Fable 5.1 (or Opus 5.5) with the binding-controls beta and drop_block. Setting the behavior explicitly opts the request into the check on any account, so you see every mismatch without a single request failing:

# headers
anthropic-beta: thinking-binding-controls-2026-08-01

# body (audit run only, not your production default)
{
  "model": "claude-fable-5-1",
  "thinking": {
    "type": "adaptive",
    "block_binding": { "prefix_mismatch_behavior": "drop_block" }
  },
  ...
}

# then log every response's top-level input_transformations[]
# reason: "prefix_binding_mismatch"  -> your code edited history, fix it
# reason: "model_binding_mismatch"   -> a router moved the conversation

Fix every prefix_binding_mismatch at its source. Don't ship drop_block as a permanent setting: each dropped block means the model rebuilds that reasoning, and the docs warn that this raises output tokens. If you need to change tools mid-conversation, use the inline tool changes beta, which keeps the history append-only. The same append-only discipline is what made message threads work in my tests.

Why Did "Answer Without Deliberating" Stop Working?

Anthropic says Fable 5.1 usually obeys a system prompt line like "answer directly without deliberating" and Fable 5.2 doesn't at medium effort and above. I tested it with a small constraint puzzle (six parcels, five lanes, seven rules, "give the assignment and nothing else"), two runs per cell:

Effort + promptFable 5.1Fable 5.2
medium, plain system prompt0 thinking, reasoned in the visible answer (2/2)161-197 thinking, clean answer (2/2)
medium + "Answer directly without deliberating"235-238 thinking221-245 thinking
high, plain278-291 thinking277-281 thinking
high + the same line233-298 thinking232-273 thinking

All 16 answers were correct. What surprised me was the first row: Fable 5.1 at medium skipped thinking and worked the puzzle out loud in its reply, ignoring "nothing else" both times. Fable 5.2 thought first and returned six clean lines, and it was still cheaper per request ($0.0144 vs $0.0184). The second surprise: on this task the line didn't suppress thinking on either model. It added thinking on both. Two runs per cell is a small sample, but the direction is the one the docs describe.

The fix is to delete those lines and use effort instead. If you relied on one to fit a tiny max_tokens, raise it, because thinking counts against that budget and a response can stop after the thinking block with no text. The levels are explained in my effort parameter guide, and the API default on Fable 5.2 is high, not medium.

Should You Use Fable 5.2 or Opus 5.5?

Anthropic's own advice is to start on Opus 5.5 and move up only when evals at higher Opus effort fall short. My numbers back that for routine work. On the four easy tasks every model scored 4/4, and Opus 5.5 cost about half as much per request as Fable 5.2 while generating just as fast (85 vs 79 tokens per second). Its first token was the slowest of the three today, though.

Where Fable 5.2 earns its price is hard, long work. Anthropic reports it matching Opus 5.5's best FrontierCode score at high effort for roughly half the cost per task, and beating it on robotics and knowledge-work benchmarks by wide margins. Those are vendor numbers. My take: if you're on Fable 5.1 today, move to 5.2 this week, because it's cheaper and faster for the same job. If you're on Opus 5.5 and happy, keep it, and route only your hardest jobs up.

How I Tested

November 10, 2026, from a Mac mini in Allen, TX. Because my API key had no credit, every request went through Claude Code 2.1.321 in headless mode (claude -p) on a Max plan, with no tools, no MCP servers and a one-line system prompt. Claude Code builds the actual API request, so absolute latency includes its overhead; the comparisons hold because every model got the same setup. Speed runs used stream-json with partial messages and a timestamp per event, and generation speed is visible output tokens divided by the time from first to last text delta. Token counts and costs come from the usage block Claude Code returns at list prices. 74 requests in total cost about $1.08.

Moving an Agent to Fable 5.2?

I build and migrate Claude agents in production. Send me your agent loop and a day of logs and I'll tell you what breaks on 5.2, what it will cost, and which jobs should stay on Opus.

Related Posts