Fable 5.2: The Interesting Part Is the Work We Stopped Attempting

I've been using Fable 5.2, and I'm liking it: strong capability, fast responses, and a 1M-token context window. Why that combination matters, what the release promises, and the integration details worth reading.

I’ve been using Fable 5.2, and the short version is: it’s very good. It’s fast, the 1M-token context window is welcome, and I’m genuinely enjoying using it. That’s my feedback before we get anywhere near a benchmark table.

That combination matters. Capability gets me interested in a model. Speed matters when I actually have to work with it. A larger context window gives me more room for the work itself. Having all three is a much better pitch than another leaderboard victory.

Anthropic’s announcement includes black holes, a formalized proof of Fermat’s Last Theorem, and a thousand agents building an operating system. Those are impressive claims. But alongside my own positive experience, the example I kept coming back to was a Python service rewritten in Rust.

Not because Rust makes an announcement automatically interesting. Because everyone who has operated systems for long enough has a version of that service: expensive to run, unpleasant to change, and never quite broken enough to justify the migration. It stays on the backlog until the engineer who understood it leaves. Then it stays there more permanently.

Anthropic says a team of agents running an earlier version of Fable 5.2 migrated a critical production service from Python to Rust. The resulting service reportedly starts about 26 times faster, and the company describes it as more efficient and more reliable. Those are Anthropic’s results, not mine, and startup speed is not a substitute for a production performance profile.

But the interesting question is bigger than the multiplier. How much engineering work have we stopped attempting because the cost of doing it properly never survived planning?

That is the bigger case for Fable 5.2 I want to examine. My experience so far is positive; the migration results and performance figures below come from Anthropic, not from a controlled comparison I ran. Those are different kinds of evidence, and I want to keep them separate.

The ceiling moved. The default doesn’t have to.

Fable 5.2 and Mythos 5.2 are two configurations of the same underlying model. Fable is the broadly available product with additional cybersecurity and biology safeguards; Mythos is available to organizations admitted through Anthropic’s verification programs. Do not read a Mythos security result and assume your Fable session has the same unrestricted capability.

The documented Fable specs are substantial: a 1M-token context window, up to 128K output tokens, always-on adaptive thinking, and the API model ID claude-fable-5-2.

The context window is one of the things I like about it. More room for code, documentation, and the history of a task is useful, even though fitting a million tokens is not the same as using every one of them correctly. I am not claiming to have stress-tested the full window.

I also appreciate the recommendation attached to those specs. Anthropic still tells people to start with Opus 5.5 for most coding and knowledge work, then move up when the task warrants it. The company selling the more expensive model is not claiming every README edit needs it. Good.

For deciding where the premium pays off, that is a sensible starting point. Look at the work the current model cannot reliably finish: the migration spanning several packages, the bug whose explanation crosses three services, the refactor that needs to preserve behavior nobody documented. Keep routine work on the model already doing it well.

A higher ceiling is useful without becoming the default for every request.

The thousand-agent demo is impressive. It is also a thousand-agent demo.

In Anthropic’s operating-system experiment, Fable coordinated more than a thousand subagents over eight days, starting from an empty folder. The result reportedly boots on a laptop and includes drivers, persistent storage, a graphical interface, a login screen, and an installer.

That deserves attention. It does not establish that the result is secure, maintainable, or ready to replace the operating system on your workstation. A working prototype and a system you are prepared to support are different achievements.

The mathematical result is worth being precise about too: a team of a thousand Fable 5.2 agents formalized the proof of Fermat’s Last Theorem in 30 hours. They did not discover the theorem or produce its first proof. Formalization turns a proof into something a computer can check, which is a serious accomplishment without borrowing credit from a different one.

What connects these examples is sustained, coordinated work with an artifact at the end. Not a clever answer. Something that can boot, be checked, or be tested against existing behavior.

That is the direction I find exciting. For infrastructure work, I would rather have an agent carry a difficult migration through tests, compatibility checks, and a reviewable diff than watch it generate another application nobody intends to maintain. The unglamorous projects are where a lot of the value is sitting.

Cheaper per token is welcome. Cheaper per finished task is the point.

The standard API price is now $8 per million input tokens and $40 per million output tokens, down from $10 and $50 on Fable 5.1. A 20% reduction is welcome. It is still twice Opus 5.5’s listed input and output prices.

Anthropic also reports up to 30% faster output generation than Fable 5.1. Optional fast mode promises up to another 2.5 times the token-generation speed, at $16 input and $80 output per million tokens. Neither figure means your entire agent task finishes that much faster. Tool calls, builds, tests, and retries still take time.

The more interesting claim is from Anthropic’s early FrontierCode 2.0 evaluation: Fable 5.2 at High effort scored about level with Opus 5.5 at Max, for roughly half the cost per task.

Vendor evaluation, particular workload, particular effort settings. Not a universal discount. But it illustrates why comparing token prices alone can get the decision backwards. An expensive model that finishes the job cleanly can cost less than a cheaper one that spends six attempts rediscovering the same mistake.

The reverse is just as possible. Give the expensive model a vague assignment, let it spawn subagents freely, and you can buy a very elaborate failure. Anthropic’s own behavior notes warn that subagents can account for a large part of session cost.

The number I would measure is the cost of an accepted result, including retries and review. A patch that needs an hour of repair did not become cheap because the API invoice was small.

Read the migration guide before changing the model string

There is a less photogenic part of this release that matters to anyone running a custom agent harness.

Fable 5.2 enforces its conversation-prefix check across all accounts. If your code changes the system prompt, tools, or an earlier message and then sends back a thinking block bound to the old history, the request can fail with a 400 error: The block is bound to a different conversation.

That includes integrations that worked with Fable 5.1 on older accounts. The migration documentation is explicit about that trap.

An agent harness that rewrites old messages, swaps tool definitions in place, or compacts history on the client should not assume this is a model-ID-only upgrade. There are supported mechanisms for compaction and mid-conversation changes. There is also a beta option to drop invalid thinking blocks instead of rejecting the request, but the docs call it a stopgap and warn that dropping them can increase output-token usage.

Model switching has a boundary too. Fable 5.2 and Mythos 5.2 can read each other’s thinking blocks; other models cannot read those blocks. A fallback request can succeed while losing that preserved reasoning. That is not the same as losing the entire conversation, but it is also not a transparent continuation of the same state.

These are documented behaviors, not bugs I found in testing. They are exactly the kind of detail I want to know before a long-running session encounters them halfway through a migration.

Better safeguards are not your permission boundary

Anthropic reports roughly 55% fewer unnecessary cybersecurity and biology blocks in early testing compared with Fable 5.1. That is useful if legitimate work gets interrupted less often. It does not mean those restrictions disappeared.

The launch describes fallback responses from Opus 4.8 for blocked cybersecurity work and Opus 5 for biology. In a custom API integration, do not assume that happens automatically: the docs describe refusal handling and optional fallback mechanisms. An HTTP 200 can carry stop_reason: "refusal". Successful transport is not proof that the requested work was completed.

There is a data-handling decision as well. These models normally require 30-day retention for safety monitoring. Anthropic describes an authorized enterprise route to zero data retention, including Enterprise Frontier Safeguards in private beta. That is not blanket ZDR for everyone holding an API key.

None of this replaces your own controls. A model’s misuse classifier is not the thing that should stop an agent from deploying to production without approval. That boundary belongs in credentials, permissions, and the workflow around it.

I wrote about Fable 5 disappearing from a live session when access was suspended earlier this year. A more capable release does not erase that experience. Keep a fallback you have actually exercised, and make sure it can continue from explicit task state and artifacts rather than assuming another model can inherit every part of the first one’s reasoning.

Where I land

I’m liking Fable 5.2. Not just the announcement, not just the idea of what it might eventually do. The model I’ve been using is very good, feels fast, and gives me the context space I want. The caveats above are things to account for, not a polite way of saying I don’t recommend it.

The bigger opportunity is revisiting work that has been sitting untouched because doing it properly looked too expensive. That is a more useful promise than being the best model for absolutely everything.

I would give it a difficult, bounded project with a known baseline: a migration with compatibility tests, a performance problem with a reproducible workload, or a refactor with acceptance criteria written before the agent starts. Compare it with the model already in use. Count total cost, elapsed time, interventions, and how much of the result survives review.

If it clears work the cheaper model cannot, or clears the same work with substantially less supervision, the premium has a reason to exist. If it produces a larger diff and a more confident explanation of unfinished work, it doesn’t.

My experience gives me a reason to keep using it. The release gives me reasons to push it further. Neither requires handing over production credentials or moving every task onto the most expensive option.

There is probably a project on your backlog that everyone agrees should happen and nobody wants to own. That is where I would start. Not with a thousand agents building an operating system. With the service everyone is tired of apologizing for.