Updated: September 2026.
On September 1, 2026, Anthropic announced Claude Fable 5.1 and its twin, Claude Mythos 5.1. The press release focused on benchmark results, but there were two more noteworthy details elsewhere. First: the price per token hasn’t changed a bit—it’s still $10 for one million tokens in, and $50 for one million tokens out—yet the company claims the bill has decreased by about a quarter. Second: its technical notes are full of lines beginning with “returns a 400 error.”
Those two details say more about this model than any benchmark results. This article analyzes Fable 5.1 through its own API—because every feature that’s been left out is a design decision, and design decisions are more revealing than press releases.
One model, two layers of protection
The first thing to clarify: Fable 5.1 and Mythos 5.1 are the same model. According to Anthropic itself, they differ only in the level of safety barriers. Fable 5.1 is widely available; Mythos 5.1 is only available to users through a trusted access program, with safety barriers specifically designed for cybersecurity and life sciences work.
This is a noteworthy distinction, and it’s not merely a technical matter: the company is separating CAPABILITY from PERMISSION. Given the same set of weightings, what a user can do depends on whether they have been verified or not. Previously, that boundary lay within the model—a robust model came with strict safeguards, and legitimate users were subject to the same false positives as malicious users. Now the boundary has been pushed outward, becoming a matter of identity and contracts.
The rest of the specifications table: model ID claude-fable-5-1, one million-token context window (with the maximum limit also serving as the default), maximum output of 128,000 tokens, and available on all major platforms, including Amazon Web Services, Google Cloud, and Microsoft Azure.
Read the number plate correctly
Anthropic released a series of benchmark scores. But upon closer inspection, only ONE metric was published alongside a benchmark for the same model generation: Terminal-Bench-Science 0.1, where Fable 5.1 achieved 52.6% compared to 24.7% for Fable 5 — 2.1 times higher.
The remaining results—Terminal-Bench 4.0 scored 55.8% (the Mythos 5.1 version scored 60.9%), Humanity’s Last Exam scored 60.9% without tools and 65.0% with tools, CursorBench 3.2.0 scored 73.4%, the strict version of OSWorld 2.0 scored 41.7%, and GDPval-AA v2 scored 1,853 — all of which are figures from the new versions only. These figures show how powerful the model is, but they do not indicate how much it has improved. These are two different questions, and confusing them is the easiest way to misinterpret a press release.
What this chart really reveals is where the biggest leap occurs: a measure of sustained work in a command-line environment, not a measure of elegant coding. That’s exactly what an agent’s work looks like—receiving a vague goal, figuring things out on its own within a shell, correcting itself when it makes mistakes, and running dozens of iterations without anyone holding its hand.
On the scientific front, the company provided two specific examples instead of scores: a success rate of nearly 50% in protein design, and a topographic map of Venus with improved resolution of 2–3 km. These are the kinds of results measured by output rather than by a scoring scale—and they are also the hardest to verify independently.
A note on methodology, in keeping with the spirit of this article on model racing: all of the figures above were released by the manufacturers themselves. They’re worth reading, but they’re no substitute for your own measurements.
Thinking is no longer just a switch
This is where the API gets straightforward. In Fable 5.1, the "think" feature is always on and cannot be turned off. Sending thinking: {type: "disabled"} results in a 400 error. Sending it the old way budget_tokens — that is, pre-allocating a token budget for the model to use — also results in a 400 error.
Instead, there is a parameter that is fundamentally different: effortfive levels ranging from low to max. The difference lies not in the syntax but in who has to make the guess. The token budget forces you to predict how difficult the problem will be in advance, then allocates exactly that amount—if you underestimate, the model gets cut off midway; if you overestimate, you pay for the unused portion. Whereas effort you simply state “how hard to try” and let the model allocate resources step by step. The person who knows how difficult the problem is is the one solving it, not the one placing the order.
Raw reasoning chains are never returned, under any settings. You can only choose the display option: the default is left blank, “summarized” returns a readable summary, and “updates”—new in this release—returns brief progress notes that the model writes between tool invocations.
That third option arose from a very practical problem: a single call on a difficult problem can run for several minutes. From a user’s perspective, several minutes of silence is indistinguishable from a system freeze. So if you plan to use this model for something where real people are waiting, you’ll need to rethink the data flow and wait times from scratch—this is no longer a model that responds in two seconds.
Do not tear out pages from this notebook
And this is the most subtle—yet most significant—change for anyone building an agent.
In Fable 5.1, thought blocks are firmly tied to the specific model that generated them and their exact position in the conversation history. Editing a past turn renders the entire subsequent chain of thoughts invalid. For accounts created on or after August 31, 2026, this is no longer a warning but a straight-up 400 error. Anthropic calls this mechanism “preserved thinking.”
To understand why it’s so heavy, you have to remember what agent frameworks have always done with conversation history: rewrite it freely. They compress older parts to save context. They trim down long tool outputs. They insert a reminder line in the middle. They rephrase old questions to make them more concise and resend the whole batch. All of these actions are based on an unspoken assumption: the past is a draft, and you can edit it whenever you want.
Fable 5.1 does away with that assumption. The past is now evidence, not a draft. Your framework must become an “append-only” framework: everything new goes at the end, with no exceptions. If you want to remind the model of something each turn, use a self-expiring system message (clear_at: "next_user_message") — it appears exactly once and then disappears on its own, instead of you having to delete the old one. And if you want to compress the history, you must do so according to the permitted format, not by cutting and pasting on your own.
Looking at the bigger picture, this follows the same line of thought as what I wrote in my post about seeds: reproducible results are gradually becoming a marketable commodity. A model that can prove, “This is indeed the chain of reasoning that led to that answer, and no one tampered with it along the way,” is a model that can be used for auditing. The price to pay is the freedom of the framework developer.
Two other points: forcing the use of tools, and the refusal
Forced tool calls have been deprecated. The old approach—forcing a model to call a specific tool—now returns a 400 error. The reason is quite clear when you consider its true purpose: most people force tool calls simply to retrieve a JSON object that conforms to a specific format. Now there’s a more straightforward way to do that: enable strict in the tool definition to ensure parameters are always valid, or use structured output. A shortcut has been removed because there is now a main path.
A denial becomes a state that must be handled. When the security classifier blocks a request, the API does not return an error—it returns an HTTP 200 status code along with stop_reason: "refusal" a classification code. This means that any code that reads the content directly without checking stop_reason will encounter an empty string and won’t understand why. However, there’s a new safety net: if you declare a fallback, when a request is rejected, the API automatically reruns that exact request on a different model within the same call, and the rejected attempt—which occurred before any data was generated—is not charged.
Pair this figure with a number from the press release, and the full picture emerges: Anthropic says Claude Code users will encounter about 60% fewer instances of cybersecurity barriers intervening per session compared to Fable 5, and the model is now permitted to be used to find software vulnerabilities. These are two sides of the same coin: relaxing restrictions in the right places and providing an escape route for the instances where a false positive still occurs. False positives are the price legitimate users must pay for security barriers; reducing that cost is a real feature, not just a gimmick.
Economics Corner: The Cost Savings Lie in the Cache
Let’s return to the paradox mentioned at the beginning of the article. The token price at entry and exit remains unchanged. What changes is the price retrieved from the cache: it’s 75% cheaper, now at $0.25 per million tokens.
Why would such a seemingly minor change reduce the bill by a quarter? Because in an agent loop, most of the tokens you pay for aren’t new tokens. If an agent runs twenty times, it sends back nearly the same prefix twenty times: the system description, the tool list, and the history from the beginning. The new content generated each iteration is just a small snippet. Reducing the cost of re-reading data directly lowers the cost of the largest portion of the bill—and that’s why the company estimates that standard use cases save about 25%, while long-running agents can save up to about 45%.
Three practical consequences follow from this.
One: Keeping the prefix consistent is now the cheapest leverage you have. The cache aligns to the prefix—changing a single byte at the beginning corrupts the entire rest. A timestamp in the system description, a dynamically sized tool list—that’s enough to ensure every operation incurs the full cost. This error used to be costly; now it’s far more expensive, because the portion you lose has become four times cheaper.
Two: "effort" is the second cost control knob, and it’s real. Following the same model, lowering the effort level means fewer tokens, fewer tool calls, and fewer prompts. For classification tasks or short Q&A, the low level usually costs nothing; for long-form programming, it’s worth raising the level.
Three: Measure the cost per JOB COMPLETED, not per call. Fable 5.1 costs twice as much as Opus 5—$10/$50 versus $5/$25—and five times as much as Sonnet 5. A call that’s cheaper but takes three rounds to complete isn’t actually cheaper. This is the only meaningful comparison, and it’s one that only your own data can answer. Read our article on the token-pricing algorithm to understand why the numbers on the price list aren’t the actual amounts you pay.
Finally, there are two costs that aren’t measured in money, and they might be what holds you back: Fable 5.1 requires a 30-day data retention policy—any organization operating without such a policy will be automatically rejected unless specifically authorized by Anthropic—and it does not offer a Priority Tier, meaning you cannot purchase priority access when the system is busy.
Prediction
- “Append-only” will become the default for all agent frameworks. When a major provider makes rewriting history a hard error, libraries will follow suit—and the habit of arbitrarily cutting and pasting context will be remembered as a temporary phase.
- The pricing battle has shifted from tokens to caching. The price per token has remained unchanged for two consecutive model generations, while the cost of re-reading has dropped by 75%. Price competition will center on “re-reading what is already known,” as that is where the real volume lies.
- The level of effort will be visible to end users. Today
effortit’s a developer parameter; soon there will be products allowing users to choose between “quick answer” or “think it through, but it’s more expensive” right on the interface. - The Fable/Mythos division model will be emulated. Separating capability from permission—using the same model but with different barriers based on user verification—resolves the dilemma every lab is currently facing, so it’s unlikely that just one company will handle it.
- Content provenance will shift from a feature to a contractual term. Once content generated by the model can be properly labeled, buyers in regulated industries will begin to require that label, rather than simply using it if available.
- But self-reported metrics alone will still not be enough. As long as only one metric in the entire suite has a comparable benchmark from the same generation, serious buyers will still have to build their own metrics based on their own work—and that remains the most labor-intensive part of the entire process.
Thảo luận