gloss

Fable 5.2 Fails the History Edit Your Account Got Away With

Claude Fable 5.2 shipped on 9 November at $8/$40 per million tokens, 20 percent below 5.1, and it is the first generally available Fable model that returns a 400 on every account when a thinking block's history has been edited.

A heavy metal chain spans a weathered green gate, with an open threaded connector at its center and a blurred building beyond.
  • Claude Fable 5.2 shipped on 9 November at $8 per million input tokens and $40 per million output, 20 percent below Fable 5.1. It is also the first generally available Fable model that returns a 400 on every account when a thinking block's history has been edited. On Fable 5.1, organisations created before 31 August 2026 sent edited histories through with no error, and the model read the stale blocks anyway.
  • The edit is usually a harness habit, not a bug anyone filed: a system prompt that re-renders the date or the git branch, a tool list that grows when an MCP server connects, a client-side summary that keeps the last few turns verbatim. GitHub holds 364 issues quoting the error, and Zed's is four days old. Those were new-account hits on Opus 5.5 and Sonnet 5.5. On Fable 5.2 they reach everyone.
  • I read four harnesses on 10 November. OpenCode passes by sending drop_block on every request, the stopgap Anthropic says raises output tokens. Roo Code never captures the Anthropic signature, so it has no block to fail and no reasoning to carry. Cline's fallback compaction and LiteLLM are each one setting away. If Claude Code or the Agent SDK builds your requests, nothing changes.

The launch numbers are already everywhere. Fable 5.2 costs 20 percent less than 5.1, generates output up to 30 percent faster, keeps the 1M context window and 128k output tokens, and gets a fast mode at $16 and $80 with no beta header. The what's-new page lists four changes that can break code. Three are the ordinary kind: the old computer_20251124 tool returns a 400 everywhere except Bedrock, the advisor tool wants a 5.2 advisor, and no other model can read 5.2's thinking blocks.

The fourth is not new at all. The check has run since September. What changed is who it applies to.

The check that waited for your account

Since Fable 5.1 launched on 1 September, the API has bound every thinking block to what came before it: the top-level system prompt, the tools array, and every earlier message. Send the block back after any of those changed and the block is invalid. You may drop thinking blocks from the start of the history, from the end, or all of them. A gap in the middle invalidates every block after it.

What happened to an invalid block depended on when your organisation was created. The cutoff is 00:00 UTC on 31 August 2026. Accounts from that day on got a 400. Older accounts got, in the words of the enforcement table, "No error (failing blocks reach the model)". The same split applies to Opus 5.5, Sonnet 5.5 and Haiku 5.5. For Fable 5.2 and Mythos 5.2 the table has one entry in both columns: 400 error.

The migration guide says it without hedging: "code on Claude Fable 5.1 that edits its history can run without errors on an older account before the switch and fail after it." The error looks like this:

messages.1.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".
The `system` prompt differs from the one this block was created with.

On 14 September Anthropic added a way for older accounts to see this coming. With the thinking-binding-controls-2026-08-01 header, the response lists each block that failed the check but was let through, as thinking_mismatch_allowed. Most code never sends the header, so most code never saw those entries. Your harness has been editing history for ten weeks and the API has been quietly reading the result.

What counts as an edit

The preserved-thinking page lists the patterns to look for. A system prompt rebuilt each request with the date, a mode flag, or the tools of an MCP server that connected after the first turn. A first user message that re-renders project context. Old tool results cleared or shortened. A client-side summary that keeps recent turns verbatim with their thinking. A tool added to or removed from tools. A reminder appended to a user turn and taken out later.

Every one of those has already produced a bug report. Searching GitHub issues for the error sentence returns 364 results. In Zed, filed on 6 November, auto-compaction builds its request with the system prompt rendered without tools and replays the old thinking blocks. The code attaches drop_block only when thinking is allowed on the request, and the compaction request has it off. In Mastra, filed on 4 November, the coding agent rebuilds its instructions every step and reads the git branch live, so a checkout inside the sandbox changes the system prompt halfway through a turn. In VS Code, Copilot Chat's custom Messages endpoint fails at content block 66 of a long tool loop. In OpenCode, a Sonnet 5.5 user lost a session and asked for $23 of context back.

All four name Opus 5.5, Sonnet 5.5, Haiku 5.5 or Fable 5.1, models where the 400 depends on the account's age. Fable 5.2 removes that condition.

Four harnesses, read on 10 November

I cloned the main branch of four projects and looked for how each sends thinking blocks back and what it does when history moves. I did not send their requests to Fable 5.2. The rule is in the docs, and the issues above show it firing on the sibling models.

OpenCode 2.2.6 has the most complete answer. In packages/ai, a function called applyThinkingBindingDefault sets prefix_mismatch_behavior to drop_block for every Claude model that supports binding and adds the beta header. The Bedrock route does the same, since 2.0.20. OpenCode needs it, because its compaction keeps 15,000 tokens of recent turns verbatim beside a summary it writes itself, which is the exact shape the docs say fails the check. The docs also call drop_block a stopgap: the API discards the failing block and every thinking block after it, and the model re-creates that reasoning, which costs output tokens. On Fable 5.2 those are $40 per million. A provider option, blockBinding: false, turns the default off. Flip it and the 400 comes back.

Roo Code 3.53.0 cannot fail the check, for a reason that is less reassuring. Its Anthropic provider carries a comment in the streaming loop: capturing the signature "would require using stream.finalMessage()". Only the Gemini provider implements getThoughtSignature, and the task history stores a thinking block only when a signature exists. So on the Anthropic provider, Roo sends no thinking blocks back at all. Every turn starts without the previous turn's reasoning, which is the drop_block cost paid on every request, by construction. Its Anthropic model list has no Fable model in it.

Cline's SDK core 0.2.0 sits in between. Its compaction without a summariser strips thinking from the older answers it archives, with a comment that those blocks "carry no value there". It keeps the newest messages of the current turn verbatim, thinking included, after dropping the messages before them. That is the keep-tail shape. Nothing in the repository sets block_binding.

LiteLLM 1.110.0 has the types for prefix_mismatch_behavior and input_transformations and forwards both. It also strips thinking.block_binding from a request when drop_params is on and the beta header is missing. Set drop_block without the header and the proxy removes your setting on the way out.

The blocks only go one way

Fable 5.2 reads thinking blocks from Opus 5.5, Sonnet 5.5, Haiku 5.5, Fable 5.1 and the models before them, so a conversation that moves onto it keeps its reasoning. Nothing but Mythos 5.2 reads Fable 5.2's blocks. Its server-side fallback targets are Opus 4.8 and Opus 5, so a refused request that falls back lands on a model that drops every Fable 5.2 thinking block in the conversation. The drop is silent, unbilled, and listed as model_binding_mismatch only when you send the beta header. The blocks are also bound to the organisation that produced them. Replay a stored conversation through another account and they vanish the same way.

Before you change the model ID

Run one session with the beta header and prefix_mismatch_behavior set to drop_block, log input_transformations, and fix every prefix_binding_mismatch entry. Do this even if Fable 5.1 never complained, because on an older account it would not have.

Then make the history append-only. A date, a branch name or a mode flag goes in a mid-conversation system message, not the top-level prompt. Tools change through tool_addition and tool_removal blocks. Compaction either runs on the server, where the kept turns stay valid, or takes the simple form the docs recommend: one user message holding the summary and the next instruction, with nothing older replayed.

Check every router and fallback that can move a conversation off Fable 5.2, and expect the destination to run without its reasoning. Fable 5.2 also has its own rate limit, separate from the bucket Fable 5.1 and Fable 5 share. And under zero data retention every request returns a 400 until a workspace has 30-day retention turned on.

Claude Code 2.1.321, released the same day, made Fable 5.2 its default Fable model and builds its own requests, so none of this applies there.

The price cut is real. So is the check, and for ten weeks it has been reporting only on organisations younger than most harnesses. Fable 5.2 is where the two columns of that table become one.