Fable 5.1 Breaks Two Operator Assumptions: `tool_choice` Force-Calls and Thinking Block Reuse

When Claude Fable 5.1 launched on September 1, two changes in the release notes were easy to read past. One is a 400 error that breaks force-call tool patterns immediately. The other is a constraint on thinking blocks that silently degrades multi-turn agentic sessions — and for accounts created after August 31, it becomes a hard 400 as well. Neither is announced as a deprecation with a grace period. Both are in effect today.

The tool_choice removal: what breaks and why Anthropic made this cut

Fable 5.1 and Mythos 5.1 do not support tool_choice of type any or type tool. Sending either returns a 400 error. auto and none are unchanged.

The any type tells Claude it must call at least one tool this turn. The tool type forces a specific named tool. Both are commonly used by operators who need structured output from an agentic step — for example, a classification pipeline that expects a tool call JSON rather than prose, or a data-extraction agent that must return a typed schema every turn.

On Fable 5.1, neither is available. The practical reason Anthropic gives is that the feature's function — guaranteeing schema-conformant tool input — is now better served by two separate mechanisms: strict tool use (strict: true on the tool definition, which uses grammar-constrained sampling) and structured outputs (a top-level output_schema parameter that returns a JSON object directly). Both give harder schema guarantees than tool_choice: tool ever did, since they enforce at the token-sampling level rather than as a post-generation check.

The migration shape changes substantially depending on what you were using force-call for:

If you were using tool_choice: tool to guarantee a structured return value from a single named tool, migrate to structured outputs. Instead of defining a tool and forcing the model to call it, define output_schema directly on the messages request. You get back a JSON object matching the schema in the response body rather than inside a tool_use block. You no longer parse a tool call to extract the payload.

If you were using tool_choice: any to ensure the model doesn't respond with prose when it should take an action, migrate to strict tool use. Add "strict": true to each relevant tool definition. The model still chooses which tool (and whether to call one in auto mode), but when it does call a tool, the input will always match your JSON Schema — no type coercions, no missing required fields. You may also want to adjust your system prompt to reinforce when a tool call is expected.

If you were using tool_choice: tool to force a specific tool call as an input validation workaround — for example, to work around a prompt injection risk where a bad actor could redirect the model to a different tool — you need to rethink the approach entirely. strict: true handles the schema shape, but tool selection remains model-driven. If your security model required a specific tool to always execute regardless of user input, that guarantee no longer exists on Fable 5.1 and you will need to implement selection validation outside the model.

The cross-provider context matters here. OpenAI's tool_choice: required (analogous to any) and tool_choice: {"type": "function"} (analogous to tool) are still available on their latest models as of this writing. Google Gemini has a tool_config.function_calling_config.mode: ANY equivalent. Operators running routing layers that normalize tool forcing across providers will need Fable 5.1 to branch to the structured-outputs or strict-tool-use path rather than translating to the force-call parameter.

The thinking block version gate: model-binding and conversation-binding

The second change is more subtle and has two separate enforcement layers.

Layer 1: model-binding. Thinking blocks produced by Fable 5.1 or Mythos 5.1 are readable only by those models or newer ones. If your session falls back to an older model — for example, after a classifier refusal triggers a fallback to Claude Sonnet 5 — the older model cannot read the thinking blocks from the Fable 5.1 turn. The API drops them from the request. The older model reasons again from the visible messages, without access to the prior chain of thought.

Without the thinking-binding-controls-2026-08-01 beta header, this drop is silent. The API doesn't tell you it happened. The older model just gets the messages minus the thinking content. With the beta header, the response includes an input_transformations field reporting each dropped block as model_binding_mismatch.

The inverse does not apply: Fable 5.1 reads thinking blocks produced by every older model on the list (Claude Opus 5, Fable 5, Mythos 5, and earlier). Moving a conversation up to Fable 5.1 keeps the prior reasoning. Moving it down to anything older loses the Fable 5.1 reasoning for that request (and until the conversation returns to Fable 5.1).

Operators running model-fallback chains need to account for this. A three-step routing pattern — try Fable 5.1, fall back to Opus 5 on cost, fall back to Sonnet 5 on timeout — accumulates thinking blocks at each successful Fable 5.1 step. Each fallback step drops those blocks silently. The model behaves correctly, but the reasoning efficiency you paid for on the Fable 5.1 turns does not transfer.

The thinking-binding-controls-2026-08-01 beta header adds one more knob: thinking.block_binding.prefix_mismatch_behavior, which selects between rejecting and dropping blocks whose conversation history has changed. That brings us to the second enforcement layer.

Layer 2: conversation-binding (prefix-mismatch enforcement). A Fable 5.1 thinking block's signature covers the system prompt, the tools list, and every message that preceded it. If any of those change before the block is replayed in a later turn, the block is no longer valid in that conversation.

For accounts created on or after August 31, 2026, the API enforces this immediately: replaying a thinking block after the prefix has changed returns a 400 error.

For older accounts, the check is currently recorded in the signature but not enforced — unless the request sets thinking.block_binding.prefix_mismatch_behavior. Anthropic states clearly that enforcement for older accounts is coming on future models. The window to fix your application before it's enforced on you is now.

The patterns that break this check are exactly the ones that seemed harmless before: editing the system prompt between turns (common in multi-tenant systems that inject per-user context), removing or adding a tool during a session, or any history truncation or message editing done to manage context length. If your application does any of these between turns that contain thinking blocks, you are incompatible with the prefix-binding rule.

The remediation paths the docs point to are:

• Append-only conversation history. Never edit prior messages. Inject new context as a new message rather than modifying the system prompt. This is the same pattern that keeps the prompt cache warm, so the change tends to reduce latency and token cost as a side effect.
• Turn-scoped system messages (now in beta via mid-conversation-system-clear-at-2026-08-21). Set clear_at: "next_user_message" on a mid-conversation role: system message to inject per-turn context without touching the top-level system prompt. The message counts for that turn only, then sits in history at zero token cost and doesn't move the cache breakpoint or invalidate prior thinking blocks.
• Test against enforcement now by sending thinking.block_binding.prefix_mismatch_behavior: "error" with the beta header. Older accounts receive the same 400 errors new accounts get, surfacing incompatible patterns in your test environment before they're enforced in production.

If you ship a tool, SDK wrapper, or framework that other developers run with their own API keys, the prefix_mismatch_behavior: "error" test is especially important: your users on new accounts are already enforced, and their bugs are your bugs.

What to change before routing production traffic to Fable 5.1

The two breaking changes interact. An operator moving from Fable 5 to Fable 5.1 may be simultaneously breaking on tool_choice in the request shape and accumulating prefix-mismatch violations in thinking block handling. Running both checks in isolation misses that the fixes are different parts of the same migration.

What to audit:

1. Search your codebase for tool_choice with type: "any" or type: "tool". Every hit breaks immediately on Fable 5.1. Decide per call site whether structured outputs or strict tool use is the right replacement — they are different interfaces with different ergonomics.
2. Enable thinking-binding-controls-2026-08-01 in a test environment pointed at Fable 5.1. Watch input_transformations for model_binding_mismatch drops. If any appear in your fallback paths, add explicit block filtering or redesign the fallback to preserve only the messages.
3. Set prefix_mismatch_behavior: "error" in staging to surface conversation-history editing patterns before they become production 400s. Fix by converting mutations to appends.
4. Review multi-tenant session patterns that inject per-user context into the system field between turns. These break prefix-binding without any code change — a configuration-driven behavior that varies by tenant. Turn-scoped system messages are the cleanest fix.

The cache-repricing angle from the same release — Fable 5.1 cache reads at $0.25/MTok, which is 0.025x the base input price versus 0.1x on every other model — is a separate story. But it's worth noting that the prefix-binding enforcement and the append-only caching discipline are the same discipline: operators who implement the migration correctly to fix the thinking block constraint will simultaneously get better cache hit rates and lower input costs on Fable 5.1. The constraint and the incentive are aligned.