Claude Fable 5.1 Review
Claude Fable 5.1 is Anthropic's newest long-horizon model. Here are its features, Fable 5 differences, API price changes, and compatibility notes.
Claude Fable 5.1 is Anthropic's latest model for long-running agentic coding, multistep research, and knowledge work. This review covers what changed from Fable 5, whether the upgrade is worth it, the current API pricing, and the compatibility details that can break an integration.
The short verdict: Fable 5.1 is a meaningful update for the hardest long-running workflows, especially when they repeatedly read a large cached prefix. It is not the automatic default for ordinary coding; Anthropic still recommends starting most workloads with Opus 5 and moving to Fable when evaluations justify it.
Fact-checked September 4, 2026. Release details, specifications, prices, and migration behavior come from Anthropic's current documentation. No controlled independent benchmark was run, so capability improvements are attributed to Anthropic. OmniaKey currently lists claude-fable-5-1; gateway rates remain a separate live-catalog decision.
What is Claude Fable 5.1?
Claude Fable 5.1 is a specialist Claude model for work that needs more than a short chat turn: multi-file coding, long investigations, research with follow-up searches, and document, spreadsheet, or slide workflows. It has a 1M-token context window, up to 128K output tokens, and adaptive thinking that is always on.
| At a glance | Claude Fable 5.1 |
|---|---|
| Release date | September 1, 2026 |
| Best for | Demanding long-horizon agents, research, and knowledge work |
| API model ID | claude-fable-5-1 |
| Context / max output | 1M / 128K tokens |
| Thinking | Adaptive, always on; default effort high |
| Knowledge cutoff | June 2026 |
| Anthropic base price | $10 input / $0.25 cache read / $50 output per MTok |
The model is a successor to Claude Fable 5, not a separate Claude Code product. You can call it through the Claude API and supported partner platforms with the exact model ID claude-fable-5-1. OmniaKey also lists that exact route; check the live model list for its current gateway price.
This is an information-first review, not a claim that Fable 5.1 wins every benchmark. Anthropic reports improvements in long-horizon coding, research, vision, computer use, and office-document work; an independent result still depends on the agent, tools, permissions, prompt, and acceptance test you use.
What's new in Claude Fable 5.1?
The headline changes are:
- lower cache-read pricing while base input, cache-write, and output prices stay the same;
- stronger long-running agentic coding, research, vision, and computer-use work according to Anthropic;
- per-message
effortchanges and turn-scoped system messages (beta); - readable progress updates between tool calls (beta);
- content provenance for generated text and supported media.
There are also three migration-sensitive changes: forced tool choice can return a 400, older Claude models cannot read Fable 5.1 thinking blocks, and editing the conversation prefix can invalidate later thinking blocks. Those details matter more than a version number if you maintain your own Messages API client.
Claude Fable 5.1 pricing
All figures below are USD per one million tokens (MTok).
| Usage type | Anthropic standard rate | What it means |
|---|---|---|
| Uncached input | $10.00 | New prompt, history, files, or tool context |
| 5m cache write | $12.50 | Store an eligible prefix for five minutes |
| 1h cache write | $20.00 | Store an eligible prefix for one hour |
| Cache read | $0.25 | Read a provider-reported cached prefix |
| Output | $50.00 | Visible output plus provider-billed thinking output |
Fable 5.1 keeps Fable 5's input, cache-write, and output prices. The material price change is cache reads: $0.25/MTok instead of Fable 5's $1.00/MTok. That is a 0.025x multiplier on base input pricing, or one quarter of Fable 5's cache-read rate.
The full estimate is:
cost = uncached_input_millions × 10.00
+ cache_write_5m_millions × 12.50
+ cache_write_1h_millions × 20.00
+ cache_read_millions × 0.25
+ output_millions × 50.00
Paid tools, taxes, regional routing, retries, and a gateway's own pricing rules can add other line items. Reconcile the provider usage fields rather than estimating from the visible answer length.
Claude Fable 5.1 vs Fable 5: practical differences
The version number hides an important distinction. Fable 5.1 is not a general input or output price cut; it is a behavior and caching update with a lower cache-read line item.
| Item | Claude Fable 5 | Claude Fable 5.1 | Migration impact |
|---|---|---|---|
| Base input | $10/MTok | $10/MTok | No rate change |
| 5m cache write | $12.50/MTok | $12.50/MTok | No rate change |
| 1h cache write | $20/MTok | $20/MTok | No rate change |
| Cache read | $1/MTok | $0.25/MTok | Lower repeat-context cost |
| Output | $50/MTok | $50/MTok | No rate change |
| Context window | 1M | 1M | Capacity is unchanged |
| Maximum output | 128K | 128K | Capacity is unchanged |
Forced tool_choice | auto, none, any, or named tool | Only auto or none | any and named tools return 400 |
| Thinking-block direction | Produces older-format blocks | Reads older blocks; older models cannot read its blocks | Downgrades can drop reasoning blocks |
| Mid-conversation effort | Request-level changes can lose cache reuse | Per-message effort change (beta) | Hard and routine turns can use different effort |
| Progress updates | Text behavior from Fable 5 | Readable update blocks available (beta) | Interfaces can expose status without raw reasoning |
| Content provenance | Earlier behavior | Statistical text watermark and supported C2PA media | No request change required |
Anthropic's release notes also describe stronger long-running agentic coding, multistep research, document, spreadsheet, slide, vision, and computer-use work. Those are vendor-described capability improvements, not an independent benchmark. Measure an accepted task on your own harness before assuming that a higher model tier lowers total cost.
Claude Fable 5.1 vs Opus 5: which should you use?
Start with Claude Opus 5 for most complex coding and reasoning work. Anthropic lists it at $5 input and $25 output per MTok, half Fable 5.1's base rates, and it does not require a task to justify the specialist tier before you learn whether it can pass.
Move to Fable 5.1 when an Opus 5 run at an appropriate effort level still falls short, the task must remain coherent for hours, or a large stable prefix is read across many agent turns. The decision should come from accepted-task rate, retries, latency, and human correction time rather than the newer version number alone.
Three Fable 5.1 cost examples
These examples use only the published token categories. They exclude paid tools, taxes, retries, and gateway-specific charges.
Example 1: a first uncached investigation
Assume one million uncached input tokens and 100,000 output tokens:
1 × $10.00 + 0.1 × $50.00 = $15.00
The 1M context window lets the request hold a large amount of context. It does not turn that context into a free allowance.
Example 2: a five-minute cached prefix
Assume 100,000 tokens are written to the 5-minute cache, 500,000 later tokens are cache reads, and the answer uses 20,000 output tokens:
0.1 × $12.50 + 0.5 × $0.25 + 0.02 × $50.00 = $2.375
The cache read is cheap, but the initial write is still charged. The calculation is valid only when the provider reports those tokens in the corresponding buckets.
Example 3: a long-lived one-hour prefix
Assume one million tokens are written to the 1-hour cache, eight million are later read from cache, and the model produces 500,000 output tokens:
1 × $20.00 + 8 × $0.25 + 0.5 × $50.00 = $47.00
The output line dominates this workload. A long context window does not make a long answer inexpensive, especially when adaptive thinking takes more output budget.
When prompt caching pays back
Fable 5.1 uses the same cache-write multipliers as Fable 5:
- a 5-minute cache write is 1.25x the base input price;
- a 1-hour cache write is 2x the base input price;
- a cache read is 0.025x the base input price on Fable 5.1;
- the minimum cacheable prompt is 512 tokens.
For a repeated prefix, a 5-minute cache usually pays back on the first read. A one-hour write normally needs two cache reads to beat sending the same prefix uncached each time. That is an arithmetic break-even point, not a promise that every client will produce a cache hit.
Keep stable system instructions, tool definitions, and large reference material in the cacheable prefix. Put changing task details after that prefix. A prompt that looks similar to a previous prompt is not automatically a cache hit; inspect cache_read_input_tokens and cache_creation_input_tokens in the response usage.
Model IDs and API access
Use the exact model ID for reproducible tests:
| Platform | Model ID |
|---|---|
| Anthropic Claude API | claude-fable-5-1 |
| Amazon Bedrock | anthropic.claude-fable-5-1 |
| Google Cloud | claude-fable-5-1 |
| Microsoft Foundry | claude-fable-5-1 |
| Claude Platform on AWS | claude-fable-5-1 |
The fable alias in Claude Code resolves to the latest Fable model when your account and provider expose it. Pin claude-fable-5-1 in evaluations and production configuration when reproducibility matters.
OmniaKey currently provides claude-fable-5-1 through its own catalog and billing boundary. Check the live catalog for the current gateway price, create a scoped key in API tokens, and use the localized API quick start for setup.
After the catalog confirms the route, an Anthropic-compatible smoke request has this shape:
curl https://api.omniakey.com/v1/messages \
-H "x-api-key: $OMNIAKEY_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-fable-5-1",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "List the highest-risk assumption in this migration plan."}
]
}'
If the route is temporarily absent from model discovery, stop and recheck service status. OmniaKey should return an availability error rather than silently substituting another model.
Migrating from Claude Fable 5
The model-name change is small, but a few API patterns need review.
1. Change the model ID
model = "claude-fable-5" # before
model = "claude-fable-5-1" # after
Keep the model ID in configuration so an evaluation can record exactly which version ran.
2. Leave adaptive thinking enabled
Fable 5.1 always uses adaptive thinking. These configurations return a 400 error:
{"type": "disabled"}
{"type": "enabled", "budget_tokens": 16000}
Omit the thinking field or send {"type": "adaptive"}. Use the effort parameter to trade reasoning depth, latency, and token use. The documented default is high; sweep medium, high, xhigh, and max on your own acceptance tests instead of assuming max is always cheaper overall.
3. Replace forced tool choice
Fable 5.1 does not support tool_choice values of {"type": "any"} or {"type": "tool", "name": "..."}. Those requests return a 400 invalid_request_error.
Use auto and tell the model which tool is required in the current instruction. For schema-constrained arguments, use a strict tool definition or structured outputs:
{
"tool_choice": {"type": "auto"},
"tools": [
{
"name": "record_summary",
"strict": true,
"input_schema": {
"type": "object",
"properties": {"summary": {"type": "string"}},
"required": ["summary"],
"additionalProperties": false
}
}
]
}
If an application requires a specific tool on one turn, add the requirement as a mid-conversation system message instead of rewriting the top-level prompt or forcing tool_choice.
4. Preserve thinking blocks and history prefixes
Fable 5.1 can read thinking blocks produced by earlier Claude models, but older models cannot read Fable 5.1's blocks. A fallback or router may drop those blocks when it changes models. That is expected model binding behavior, not a successful continuation of the same reasoning state.
When your client builds the messages array itself, keep the conversation append-only. Editing an earlier user turn, rebuilding system or tools, changing an image or document's bytes, or deleting a middle turn can invalidate later thinking blocks and produce a 400 error. Use server-side compaction or context editing, or strip thinking blocks when deliberately creating a fresh client-side summary.
Claude Code and the Claude Agent SDK manage much of this history for you. Custom clients should test with Anthropic's thinking-binding-controls-2026-08-01 beta header and log input_transformations before enabling production traffic.
5. Re-run refusal and fallback tests
Fable 5.1 can return HTTP 200 with stop_reason: "refusal" and a stop_details category. Treat that response as a refusal, not as a valid text answer and not as a transport failure. Configure a bounded fallback to an approved Claude model or stop for human review. Never create an unbounded retry loop.
6. Review your client version
The compatibility path used by OmniaKey requires a Claude Code identity at or above the Fable 5.1 client gate, currently 2.1.251. If Fable 5.1 is missing from a model picker or the request is rejected before it reaches the provider, update the client and verify the configured base URL. A newer client alone does not grant Anthropic organization access, and a gateway route has its own availability list.
Common Fable 5.1 errors
tool_choice returns HTTP 400
Remove any and named tool selection. Keep auto, add an explicit instruction, and use strict tool schemas or structured outputs where the application needs machine-readable data.
thinking returns HTTP 400
Remove manual enabled or disabled thinking configuration. Fable 5.1 is adaptive-only. Lower effort or reduce the task scope when you need cost control.
Invalid signature or block is bound to a different conversation
The request changed content before a thinking block. Restore the exact system prompt, tools, and message prefix, or start a fresh conversation without the stale blocks. Do not keep retrying the same invalid body.
Unknown model
Use claude-fable-5-1, not a display name or an old alias. Check whether the active provider supports the model. On OmniaKey, check the live catalog and base URL first.
The bill is higher than the visible answer
Inspect uncached input, 5-minute and 1-hour cache writes, cache reads, output-billed thinking, tools, retries, taxes, and routing modifiers. Visible text is not a complete usage report.
Fable 5.1 is unavailable under a data-retention policy
Anthropic documents 30-day data retention for Fable 5.1 and says it is not available under zero-data-retention arrangements unless explicitly authorized. Check the provider contract and the gateway's policy before sending sensitive source code.
Is Claude Fable 5.1 worth upgrading to?
Fable 5.1 is worth testing when the task is unusually long, ambiguous, tool-heavy, or difficult to recover after a wrong turn. The lower cache-read price is especially relevant when a stable, large prefix is reused across many turns. It is not automatically the best default for routine coding: the base input and output prices remain at the Fable 5 level.
Start with Claude Opus 5 or Sonnet for ordinary work when they can pass the same acceptance test. Review the Claude Fable 5.1 model page for the current route, and use the Fable 5 model page when comparing the previous version. The broader Claude Code model guide owns family routing, while the existing Fable 5 pricing guide owns the older model's price and access analysis. For a cross-provider decision, compare the documented boundaries in Fable 5 versus GPT-5.6 Sol.
The practical metric is accepted-task cost:
accepted-task cost = successful-run charges
+ failed retries
+ human correction time
+ remediation risk
Run the same repository commit, prompt, tools, permissions, effort, and acceptance commands on each candidate. A model name is not a benchmark result.
Frequently asked questions
What is Claude Fable 5.1?
Claude Fable 5.1 is Anthropic's latest long-horizon Claude model for demanding agentic coding, research, and knowledge work. It has a 1M-token context window, 128K maximum output, and always-on adaptive thinking.
What changed from Claude Fable 5?
Input, cache-write, and output prices are unchanged, while cache reads drop to $0.25/MTok. Fable 5.1 also adds beta effort and progress controls, but forced tool choice and some conversation-history edits can now return 400 errors.
How much does Claude Fable 5.1 cost?
Anthropic lists $10.00 per million input tokens, $12.50 for 5-minute cache writes, $20.00 for 1-hour cache writes, $0.25 for cache reads, and $50.00 per million output tokens. OmniaKey currently lists the model and maintains its gateway rate separately in the live catalog.
What is the Claude Fable 5.1 API model ID?
Use claude-fable-5-1 on the Anthropic API, Google Cloud, Microsoft Foundry, and Claude Platform on AWS. Amazon Bedrock uses anthropic.claude-fable-5-1.
Is Fable 5.1 cheaper than Fable 5?
Input, cache-write, and output prices are unchanged. Cache reads are cheaper: $0.25/MTok on Fable 5.1 versus $1/MTok on Fable 5. The total task cost still depends on token mix, retries, tools, and accepted-task rate.
Does the 1M context window include free tokens?
No. It describes request capacity. Tokens placed in the window are billed as input, cache writes, cache reads, or output according to the provider usage report.
Can Fable 5.1 force a tool call?
No. tool_choice values any and named tool return a 400 error. Keep tool_choice at auto, state the requirement in the instruction, and use strict tool use or structured outputs for schema control.
Can I disable thinking on Fable 5.1?
No. Adaptive thinking is always on. Use effort and a measured max_tokens budget to control the tradeoff.
Can Claude Code use Fable 5.1?
Yes when the active provider exposes it and the client supports the model. The OmniaKey compatibility path uses a current Claude Code identity at or above 2.1.251; update older clients and then check the active provider catalog.
Does OmniaKey already provide Fable 5.1?
Yes. OmniaKey currently lists claude-fable-5-1. Check the live OmniaKey model catalog for current availability and gateway pricing.
Is Fable 5.1 suitable for zero-data-retention workloads?
Anthropic documents a 30-day retention requirement and says zero-data-retention access needs explicit authorization. Confirm the policy for the exact provider and route before sending sensitive data.
Sources checked
- Anthropic: Claude Fable 5.1 overview
- Anthropic: What's new in Claude Fable 5.1
- Anthropic: Migrating to Claude Fable 5.1
- Anthropic API pricing
- Claude Code model configuration
- OmniaKey live model catalog
- OmniaKey API quick start
Fact-checked September 4, 2026. Provider rates, aliases, model access, cache behavior, data terms, and gateway availability can change. Verify the linked first-party documentation and live catalog before committing production traffic or spend.