Anthropic's top tier gets a point release aimed squarely at long-horizon agentic work: better across coding sessions that run for hours, multistep research, and document work, at the same $10 / $50 as Fable 5 with cache reads at a quarter of the price. It also carries three breaking API changes, so this is a migration, not a model-string swap.
Input stays at $10 and output at $50 per million tokens, but cache reads drop from $1 to $0.25. That is 0.025 times the base input price where every other Claude model charges 0.1 times. Anthropic puts the effect at roughly 25% off typical workloads and up to about 45% off highly agentic ones, because a long session re-reads the same cached prefix on every turn.
Three changes are breaking. Forced tool use now returns a 400, thinking blocks are bound to the model that produced them, and editing anything earlier in a conversation invalidates every thinking block after it. If your code builds the messages array by hand, budget real time for this.
Anthropic's own guidance is to start with Opus 5 and reach for Fable 5.1 for demanding reasoning and long-horizon agentic work, or when Opus 5 at higher effort still falls short. The gap widens as effort rises. On a one-shot prompt you are paying twice Opus 5 rates for very little.
Against 74% for Opus 5 and 57% for Fable 5, at roughly ten minutes per task and using fewer tokens than either. Terminal-Bench-Science more than doubles Fable 5 (52.6% against 24.7%), which is the largest single jump in the release.
It batches parallel tool calls less reliably, writes fewer progress updates, reaches for search less at low effort, and rewrites whole files where a targeted edit would do. None of that reduces answer quality, but it moves your token bill and your latency, so re-run the evals before you believe the launch numbers.
Anthropic's launch numbers, against the model it replaces (Fable 5), the tier below it (Opus 5), and the OpenAI flagship at the time of launch (GPT-5.6 Sol). The shape of the release is narrow and deliberate: large gains on agentic and scientific terminal work, modest gains everywhere else.
| Capability | Fable 5.1 | Fable 5 | Opus 5 | GPT-5.6 Sol |
|---|---|---|---|---|
Scientific terminal work Terminal-Bench-Science 0.1 more than 2x Fable 5, the largest jump in the release | 52.6% +27.9 pts vs Fable 5 | 24.7% | 29.0% | 22.4% |
Agentic terminal coding Terminal-Bench 4.0 Mythos 5.1 scores 60.9% on the same harness | 55.8% +13.8 pts vs Fable 5 | 42.0% | 52.3% | 37.3% |
Agentic automation AutomationBench close to 2x Fable 5 | 31.4% +14.3 pts vs Fable 5 | 17.1% | 26.9% | 19.6% |
Agentic computer use OSWorld 2.0, partial credit | 77.9% +5.0 pts vs Fable 5 | 72.9% | 75.4% | not published |
Agentic computer use OSWorld 2.0, strict the strict variant is the one worth watching | 41.7% +5.6 pts vs Fable 5 | 36.1% | 39.6% | not published |
Coding CursorBench 3.2.0 | 73.4% +2.9 pts vs Fable 5 | 70.5% | 70.0% | 67.2% |
Knowledge work GDPval-AA v2 | 1853 +130 vs Fable 5 | 1723 | 1824 | 1711 |
Multidisciplinary reasoning Humanity's Last Exam, no tools | 60.9% +3.1 pts vs Fable 5 | 57.8% | 56.6% | not published |
Multidisciplinary reasoning Humanity's Last Exam, with tools | 65.0% +1.2 pts vs Fable 5 | 63.8% | 63.6% | not published |
Financial analysis FrontierFinance, rubric score | 55.9% +6.7 pts vs Fable 5 | 49.2% | not published | not published |
Numbers as Anthropic reported them on 1 September 2026. Two caveats worth carrying. First, the browser-agent result quoted in the launch (82% of tasks completed against 74% for Opus 5 and 57% for Fable 5, at about ten minutes per task and fewer tokens than either) has no published harness detail, so treat it as directional. Second, OpenAI shipped GPT-6 Astra two days later and reports 57.7% on Terminal-Bench 4.0 and 64.6% on Terminal-Bench Science, both above Fable 5.1. Any comparison table has a shelf life measured in days, which is exactly why we gate model choice on customer evals rather than launch slides.
What actually changes for an engineering team. The useful comparison is not Fable 5.1 against Fable 5, which is a clear but narrow win, but Fable 5.1 against Opus 5, which costs half as much and is Anthropic's own recommended starting point.
| Dimension | vs Fable 5 | vs latest Sonnet |
|---|---|---|
Cost of a long agent run | The headline change. Cache reads fall from $1 to $0.25 per million tokens, so a session that re-reads a large cached prefix on every turn pays a quarter of what it did. Anthropic estimates about 45% off highly agentic workloads. Cache writes and the 512-token minimum are unchanged. | Sonnet 5 is still five times cheaper on input and gets the routine turns. The cache-read cut narrows the gap on long sessions but does not close it, so the routing decision stands. |
Integration work to adopt it | Real, not nominal. Forced tool use has to come out, history has to become append-only, and any code that rebuilds the system prompt or tools array between requests has to move to mid-conversation system messages. Claude Code, claude.ai, Managed Agents, and the Agent SDK handle this for you; hand-rolled message arrays do not. | Sonnet 5 does not enforce the thinking-block binding checks, so a Sonnet-routed path keeps working while you migrate the Fable path. Useful as a staging order: migrate the expensive tier last, behind the abstraction. |
Behaviour in an agent loop | Weaker parallel tool batching, so expect more turns for the same work: more round trips, more tokens, more wall-clock time, with no loss of answer quality. Add an explicit batching instruction to the loop prompt. Fewer progress updates also means a UI that narrates the run needs `thinking.display: "updates"` or an explicit prompt asking for them. | Sonnet 5 remains the better shape for tight, high-frequency tool loops where per-turn latency dominates. Fable 5.1 earns its cost on the runs that go for hours without a human. |
When the premium is justified | On long-horizon work: multi-file features, large migrations, multistep research, and document, spreadsheet, and slide work built from a blank page. The gap over Fable 5 widens as effort rises, and shrinks to near nothing on short prompts. | Anthropic's own guidance is to start on Opus 5 and move up only when your evals at higher effort still fall short. We follow that, and we make the model prove it on customer tasks before it inherits the default. |
Inside a Kensink build, model selection is a routing decision the agent makes at runtime, not a vendor commitment frozen at design time. Fable 5.1 mostly changes the arithmetic on long sessions, because the cache-read cut is worth more than the benchmark deltas for most production agents.
Cache reads cost $0.25 per million tokens, which is 0.025 times the base input price where every other Claude model charges 0.1 times. Cache writes ($12.50 for five minutes, $20 for an hour) and the 512-token minimum cacheable prompt are unchanged, so the saving lands entirely on sessions that re-read a large stable prefix many times.
Change the effort level partway through a conversation by inserting a system message carrying an output_config. Raise it for a hard step, drop it for routine ones, and the prompt cache keeps matching. Beta header mid-conversation-output-config-2026-07-01, also supported on Opus 5.
A system message with clear_at: "next_user_message" carries system-prompt authority for the current turn, then stops rendering once a later user message exists. It stays in the array and you keep sending it back verbatim, so nothing earlier changes, the cache keeps matching, and a cleared message costs no input tokens. This is the sanctioned replacement for injecting a reminder and deleting it next request.
The model writes short status lines between tool calls, but under the default thinking.display of "omitted" those blocks come back empty, so a long agentic turn looks silent to your users. Setting display to "updates" returns the progress text while reasoning stays hidden. Beta header thinking-display-updates-2026-08-18.
Text carries Anthropic's statistical watermark on every platform where the model runs, and images, video, and audio produced through the code execution tool carry signed C2PA Content Credentials when retrieved through the Files API. The watermark adds no tokens or hidden characters, carries nothing about you or your organisation, and needs no change to your requests.
Fable 5.1 and Mythos 5.1 carry 30-day retention and are not available under zero data retention unless Anthropic expressly authorises it. Enterprise Frontier Safeguards is the path for regulated customers who need customer-controlled cloud storage, and a Detection API for watermarked content is in private preview.
Everything an engineer has to change or can now use. Three of these will break a working Fable 5 integration, and the rest are opt-in behind beta headers. If your stack is Claude Code, claude.ai, Managed Agents, or the Agent SDK, the breaking three are already handled for you.
tool_choice of type "any" or "tool" is rejected on Fable 5.1 and Mythos 5.1, on the Messages API and on the token counting endpoint. Thinking is always on, and a forced call would skip it, pushing the model's working-out into the tool arguments and lowering argument quality. Keep tool_choice on "auto" and get schema guarantees from strict tool use (strict: true) or structured outputs instead. To make the model reach for a tool rather than answer in text, say so in the prompt: it follows explicit tool instructions reliably. "auto" and "none" are unchanged.
tool_choice: type "tool" and "any" are not supported for this model.Every thinking block records its producing model and travels in one direction only. Fable 5.1 reads thinking from earlier Claude models, and no earlier model reads Fable 5.1's. A conversation that moves up onto Fable 5.1 keeps its reasoning; one that falls back off it loses reasoning for the turns that run elsewhere. When a request carries a block the target model cannot read, the API drops it before the model sees it, uncounted in input_tokens and unbilled. That drop is silent unless you ask for it to be reported.
input_transformations: [{ reason: "..." }]Modifying anything ahead of a Fable 5.1 thinking block errors on the next request. That covers editing, reordering, or removing an earlier turn, injecting per-request text you strip next time, rebuilding the top-level system prompt or tools array mid-conversation, and serving different bytes for an image or document (the check reads bytes, so a rotating signed URL for the same file is fine). Safe operations: removing a leading run of thinking blocks oldest first, server-side context editing or compaction, moving cache_control markers, and changing effort. The check is enforced for accounts created on or after 31 August 2026; older accounts only see it when the request sets prefix_mismatch_behavior. Mythos 5.1 does not run the check at all.
The block is bound to a different conversationInsert a system message carrying an output_config and the new effort level applies from the next user turn, with the prompt cache still matching. Supported on Fable 5.1, Mythos 5.1, and Opus 5.
{ "role": "system", "content": [], "output_config": { "effort": "low" } }Scope a mid-conversation system message to a single turn. It carries system-prompt authority now, stops rendering once a later user message exists, stays in the array, and costs no input tokens once cleared. Use it for per-turn reminders in a tool loop instead of editing history.
{ "role": "system", "clear_at": "next_user_message", "content": "..." }Set thinking.display to "updates" and the short status lines the model writes between tool calls come back as text while raw reasoning stays hidden. Any thinking block with non-empty text is then a status line you can render. "summarized" returns them too, mixed with summarized reasoning.
thinking: { "display": "updates" }A declined request returns HTTP 200 with stop_reason "refusal" and a stop_details object naming the policy area that fired, so handle it as a response and not an exception. Server-side fallback with fallbacks: "default" retries on the model Anthropic recommends for that category; the permitted targets for Fable 5.1 are Opus 4.8 and Opus 5. You are not billed for a refusal that arrives before any output, and fallback credit refunds the prompt-cache cost of the model switch.
stop_reason: "refusal"Unchanged from Fable 5 and still worth knowing if you are coming from an older model: adaptive thinking is always on, so thinking with budget_tokens and thinking type "disabled" both return a 400. Assistant prefill returns a 400. Non-default temperature, top_p, or top_k return a 400. Interleaved thinking is automatic with no beta header, and the raw chain of thought is never returned.
Model IDs on every platform, the limits, and the two lines that decide whether procurement signs off. Kept here so nobody has to reconstruct it from three vendor pages.
| Claude API model ID | claude-fable-5-1 |
|---|---|
| Amazon Bedrock | anthropic.claude-fable-5-1 |
| Google Cloud / Vertex AI | claude-fable-5-1 |
| Microsoft Foundry | claude-fable-5-1, on Anthropic infrastructure |
| Context window | 1M tokens, default and maximum, at standard per-token pricing across the whole window |
| Max output | 128K tokens on the synchronous Messages API |
| Thinking | Adaptive, always on. No budget_tokens, no disabling |
| Default effort | high |
| Comparative latency | Slower than Opus 5, which is the point |
| Input to output | Text and images in, text out |
| Knowledge cutoff | Jun 2026, reliable and training |
| Tokenizer | Same as Fable 5 (introduced with Opus 4.7). Roughly 30% more tokens than pre-4.7 models on the same text |
| Minimum cacheable prompt | 512 tokens |
| Data retention | 30 days. Not available under zero data retention unless Anthropic expressly authorises it |
| Retirement commitment | Not sooner than 1 September 2027 |
| Sibling model | Claude Mythos 5.1 (claude-mythos-5-1), same specs and price, Project Glasswing invitation only |
The order we work in when we move a production integration up a tier. Steps two and four are where the time actually goes.
claude-fable-5 becomes claude-fable-5-1. Run the customer eval suite before touching anything else so you have a clean before-and-after, and so you find out whether the migration is worth doing at all.
Search for tool_choice of type "any" and type "tool". Move schema enforcement to strict tool use with tool_choice "auto", or to structured outputs. Where the point was to guarantee a tool call rather than a schema, put the instruction in the prompt.
Audit anywhere the code mutates history: per-request reminders that get injected and stripped, a system prompt rebuilt each turn, a tools array assembled from current permissions. Move reminders to turn-scoped system messages, tool changes to mid-conversation tool changes, and trimming to server-side context editing or compaction.
Set prefix_mismatch_behavior to "drop_block" with the thinking-binding beta header, run a representative session, and log input_transformations. Anything reported with reason "prefix_binding_mismatch" is a place your integration edits history that you did not know about. Fix those, then pick the production behaviour.
Default effort is high, which is rarely the right level for every turn in a session. Now that effort can change mid-conversation without a cache miss, set it per step: high for planning and hard reasoning, low for the mechanical turns.
Watch for one tool call per turn where Fable 5 issued several. Add an explicit batching instruction for independent reads, and if your UI narrates the run, turn on progress updates or ask for narration in the prompt.
Anthropic reports the biology safeguards triggering 85% less often on benign requests than Fable 5, and 60% fewer false positives on the cybersecurity classifiers. The cyber posture is deliberately asymmetric: vulnerability discovery is allowed, exploit generation is not. For anyone doing legitimate scientific or security work, false-positive rate is the number that decides whether a model is usable at all.
That claim matters more than a benchmark point, because prompt injection is the live attack surface on any agent that reads untrusted content: a web page, an inbox, a customer ticket. Anthropic also reports the model is significantly less likely to reach for external resources on its own and shows reduced motivated reasoning, with refusal rates comparable to Mythos 5, Sonnet 5, and Opus 5.
Outputs carry a statistical text watermark on every platform, with C2PA Content Credentials on generated media, partly to meet EU AI Act obligations. Both Fable 5.1 and Mythos 5.1 are Covered Models with 30-day retention and are not available under zero data retention unless Anthropic expressly authorises it, which is a procurement question worth raising early rather than at signature.
Strip out the launch-day capability claims and what is left is a pricing change that lands precisely on the workload shape we build: long agentic sessions re-reading a large stable prefix. A 75% cut on cache reads moves real money in a way that three points on a coding benchmark does not.
Anthropic's own documentation says to start on Opus 5 and move up when your evals at higher effort still fall short. That is the right instruction and we follow it. Fable 5.1 is where we route the hardest residual work, at twice the input price, once a customer eval proves the gap is real on their tasks.
The breaking changes are not cosmetic. Any integration that hand-builds the messages array and injects per-request context is going to hit the thinking-block binding check, and the failure mode is a 400 in production rather than a degraded answer. Run a session with drop_block and read input_transformations before you ship.
Weaker parallel tool batching, fewer progress updates, less searching at low effort, and whole-file rewrites in place of targeted edits are all changes that pass every test you have while quietly raising your token bill and your latency. Watch cost per completed task through the migration, not just eval pass rates.
Any table comparing today's frontier models is stale within a week. This is the case for the vendor-neutral abstraction we build behind by default: the model is a config value, the eval suite is the thing you own, and switching is a decision you make on your data rather than on a launch post.
Every model we integrate runs through the same operating system. Three pillars, sixteen layers, one Compound Growth Loop. The methodology that keeps AI work from rotting after the first ship.
Read the K-FrameworkDirect API integration with the model. No LangChain, no orchestration vendor, no agent framework built on quicksand. Typed contracts, the same way we wire up Postgres.
An eval suite built from your real tasks gates every prompt and model change. Quality is measured before it ships, not vibed in a demo.
Governance, audit, and oversight wired in from day one. Who called what, with which prompt version, at what cost. Your auditors get answers, not screenshots.
A model in production without observability is roulette. We instrument every integration so engineering and finance can see the same numbers, and so a regression at 3am surfaces before a customer opens a ticket.
Tokens in, tokens out, dollars spent. Sliced by feature, tenant, and route. Budgets enforced where it matters.
Real distributions, not averages. We know which routes are slow, and why.
The same eval suite that gates a release runs continuously in production. A regression on real traffic surfaces fast.
PII scrubbed at the proxy, shipped to your SIEM. Retention controls match your compliance window.
Dashboards your team owns, not ours. At handoff you get the queries, the alerts, and the runbook. We are not in the path to read your metrics.