Anthropic released Claude Fable 5.2 and Claude Mythos 5.2 on November 9, two months after version 5.1 and a few weeks before its planned stock market debut. I’m writing about them because, by independent measurement, Fable is the strongest model anyone can buy today, and with version 5.1 I wasn’t sure what exactly you were paying for.
Fable and Mythos: one model, two doors to it…
Same model, different safeguards. Fable is available to everyone: in the Claude apps on paid plans, in Claude Code, via the API, and through Amazon, Google and Microsoft. Mythos is the same model with looser protections in cybersecurity and biology, and only vetted experts get it, through Anthropic’s verification programs. Companies on the Enterprise plan can access it through the Claude Security tool.
The price per token dropped by a fifth. A million input tokens cost $8, output tokens $40 (Fable 5.1 cost $10 and $50). Opus 5.5 is still half of that, $4 and $20. Fast mode speeds up generation by up to 2.5x, but costs double.
On a subscription with a limit. On Pro plans and standard Team seats, Fable can consume at most half of the weekly limit. Anyone with Fable in their plan gets one to three limit resets this week, depending on how long they’ve been subscribed.
Versus Fable 5.1: it finally has a reason to exist
In current measurements, Fable 5.1 fell behind Opus. In September, Fable 5.1 was in first place on the Artificial Analysis index. Since then the company has reworked the index several times and Anthropic has released Opus 5.5. In today’s version of the index, Fable 5.1 at max scores 49 points at a cost of $13 per task (about 300 CZK), while Opus 5.5 scores 59 points for $10. So you were paying more for less.
Fable 5.2 jumped 16 points. Artificial Analysis measured it at 65 points at max, the highest of all models and six more than Opus 5.5. It hasn’t published the cost per task yet. All we know is that the model is verbose: it wrote 275 million output tokens across the whole index, more than almost any model measured.
Faster and less cautious. According to Anthropic, it generates answers up to 30 percent faster than Fable 5.1. And it blocks needlessly less often: in the apps and Claude Code, the number of blocked requests dropped by roughly half, and in cybersecurity by 60 percent. A blocked query still isn’t answered by Fable; the answer comes from an older Opus.
The default effort is medium. In the Claude apps and Claude Code, Fable 5.2 runs at the medium level, and according to Anthropic it uses fewer tokens there than Fable 5.1.
Versus Opus 5.5: how much better, and at what price
| Model | AA index | Cost per task | Cost per million tokens (input/output) |
|---|---|---|---|
| Claude Fable 5.2 (max) | 65 | not yet published | 8/40 |
| Gemini 4 Carbon (high) | 60 | $7.76 | 4/20 |
| Claude Opus 5.5 (max) | 59 | $10.04 | 4/20 |
| GPT-6 Astra (max) | 57 | $6.24 | 10/50 |
| Claude Fable 5.1 (xhigh) | 50 | $10.85 | 10/50 |
| Claude Fable 5.1 (max) | 49 | $12.99 | 10/50 |
The index is version 5.0.1 from Artificial Analysis. It measures Anthropic’s models with the safeguard that redirects sensitive queries to another model.
Anthropic’s table shows the jump mainly in long tasks.
| Test | Fable 5.2 | Fable 5.1 | Opus 5.5 | GPT-6 Astra | Gemini 4 Carbon |
|---|---|---|---|---|---|
| FrontierCode 2.0 (mergeable code) | 49.1% | 32.4% | 45.5% | 42.8% | 41.1% |
| FrontierSWE v2 (long projects) | 69.9% | 56.3% | 62.3% | 65.5% | 61.2% |
| Terminal-Bench-Science | 74.6% | 52.6% | 58.7% | 68.1% | 64.8% |
| OSWorld 2.1 (computer use) | 89.3% | 83.5% | 87.2% | 79.5% | 81.5% |
| AA-Briefcase (office work, Elo) | 1785 | 1669 | 1800 | 1569 | 1611 |
| Remote Labor Index (freelance jobs) | 41.3% | 17.9% | 21.3% | 20.8% |
Measured by Anthropic, each model at its highest effort level unless noted otherwise (Fable 5.2 at xhigh in FrontierCode and at high in Remote Labor Index).
A tie in the office, a clear lead elsewhere. The table is honest in that it shows current rivals and leaves in a row where Opus leads. The biggest difference is in Remote Labor Index, where the model completes real jobs from the freelance market: Fable 5.2 handles twice as many as Opus.
The most interesting part is the promise of lower costs. According to Anthropic, Fable 5.2 at the high level gives the same result in FrontierCode as Opus at max for roughly half the cost per task. In the chart-work test, at medium it beats Opus at max for a tenth of the cost. If that holds, Fable with sensible settings can be cheaper than Opus running flat out, even though a token costs twice as much. But nobody has independently calculated that yet.
What the first tests say
Two clear wins, otherwise ties. Jonathan, the author of the Limited Edition Jonathan newsletter, had the model from Anthropic in advance and compared it across 79 runs against Opus 5.5, Codex and Grok on tasks from his own work. Fable clearly won two of them. In a code review with five known bugs, it found four, Opus two. And in a planning task scored out of a hundred, it got 99 to Opus’s 95, at the cost of roughly double the tokens and two hours per run. On the rest of the tasks it came out even.
You don’t have to run it at full power. On ordinary tasks with a correct answer, low or medium gave the same result as max, which took seven to twenty-nine times longer. Even on long tasks, nothing beat high. Max used double the tokens and solved fewer tasks in a queue of real assignments.
The weaknesses are human ones. According to the same tester, the model doesn’t know what time it is and sometimes asserts something before checking it. Earlier experience with the Fable line also points to high consumption of the subscription limit. With 5.2 that should be better; we’ll see in a week.
The big stories so far come only from Anthropic. A thousand Fable 5.2 agents formalized a proof of Fermat’s Last Theorem in 30 hours; Opus 5.5 managed a quarter of it in 18 hours. Fable designed three working electronic devices and solved two open problems in black hole physics. That’s impressive, but you have no way to verify it.
My test: does it find hidden bugs when it doesn’t know what to look for?
I wanted to know whether the model can find hidden bugs in real code when nobody tells it what to look for.
What the models got. The code of the publishing pipeline of the 3GPP Explorer site, that is, the path from processing a specification through storage and the catalog to the reader on the web. That’s roughly 740 files in the state before the fix. Plus a single instruction: find the blocking bugs that cause wrong data to be published, correct data to be lost, or a failure to be reported as success. It’s a nice problem (and a mess) that I struggled with for a long time.
What they were supposed to find. Eight real bugs that a critical review by Codex uncovered in the code and that are documented in this state. The three most serious came right in the first round: two concurrent runs that leave an older version on the site, an older document that cancels a withdrawn-version flag backed by a newer one, and broken images on the link to the latest version. I closed the list before the first model ran.
Under what conditions. Two series, 15 runs in total, all with the same prompt. In the first, Fable 5.2, Opus 5.5 and Sonnet 5.5 ran three times each at the high effort level. In the second, Fable at medium went up against Opus at max, again three runs each, to check the promise that Fable can match Opus running flat out with less effort. They could only read the code, not run it. They had no git history and no internet access, so there was nowhere to copy a ready-made solution from.
How I score. Blind, without model names. A bug with a correctly described mechanism gets a point, the right location with an unclear explanation half a point. I checked findings outside the list against the code and sorted them into valid, unverified and wrong. That way false alarms count too.
Where the test has gaps. It’s one task and three runs per model. The list of bugs was compiled by a single reviewer and may not be complete. And the scoring is done by Claude Opus 5.5, one of the tested models.
Results: Sonnet found the most bugs, Fable and Opus the worst one. The test measures how many bugs from the list compiled by Codex a model finds. The numbers are the average of three runs, with the worst and best run in brackets. For bug counts a higher number is better, for time and cost a lower one. The best value in each column is in bold.
| Model and effort | Bugs from the list (of 8, more is better) | Of which the three most serious (more is better) | Found the worst bug outside the list (runs out of 3) | All real bugs outside the list (more is better) | Findings per run | Run time (less is better) | API-equivalent cost (less is better) |
|---|---|---|---|---|---|---|---|
| Sonnet 5.5, high | 5.7 (5-6) | 2.0 | 1 | 3.7 | 7.0 | 5.1 min | $1.30 |
| Fable 5.2, medium | 3.2 (2-5) | 1.3 | 1 | 3.3 | 5.0 | 4.9 min | $4.84 |
| Opus 5.5, high | 2.8 (2-4) | 1.3 | 3 | 5.3 | 7.0 | 7.6 min | $3.63 |
| Fable 5.2, high | 1.8 (1-3) | 0.7 | 3 | 3.7 | 4.7 | 9.4 min | $7.15 |
| Opus 5.5, max | 1.7 (1-3) | 0.3 | 3 | 4.0 | 5.3 | 19.0 min | $6.51 |
It ran on my Max 20x subscription, so the cost in the table is only a conversion based on the API price list. During the test, the weekly limit for all models rose from 5 to 9 percent and the Fable limit from 2 to 7 percent. Six Fable runs thus took roughly a twentieth of the weekly Fable limit (the numbers are approximate, as I took the first reading only after the test had started). Through the API, the whole test would have cost about $70 (roughly 1,600 CZK). Among the findings outside the list that recurred across runs, I found none that was wrong. I didn’t verify the one-off findings and don’t count them.
Sonnet found the most bugs from the list. It led in all three runs and also found the most of the three most serious ones. Its worst run matched the best of all twelve other runs. It found the race between two concurrent runs that leaves an older version on the site every time, while Fable and Opus together found it once. There are two explanations. The list comes from a review by Codex and rests mainly on race conditions and poorly handled failures, exactly the kind of bugs Sonnet works through diligently, one failure path after another. And Sonnet reports more: seven findings per run, Fable at high fewer than five. The prompt asked only for blocking bugs and Fable took that more strictly. But you can’t find eight bugs with four findings.
Fable at high and Opus found the worst bug. The reader on the site deletes every chapter whose heading contains the word “contents”. The list from Codex doesn’t include it. Fable at high and Opus at both high and max found it in all nine runs, Sonnet and Fable at medium in only one run out of three each. I measured it on real documents: in specification TS 31.102 about 62 percent of the text disappears from the reader, in TS 24.501 about 14 percent. Its impact outweighs most of the list, yet in the table it counts as one item. That’s why Sonnet leads even though it missed the worst bug two times out of three. If you want to find as many bugs as possible, take Sonnet. If you don’t want to miss the worst one, take Fable at high or Opus.
More effort didn’t help. Fable at medium found more known bugs than at high, in half the time and for two thirds of the cost. Opus at max did worse than at high and took two and a half times longer. Anthropic’s promise holds here: Fable at medium beat Opus at max in a quarter of the time and for a quarter less money. With three runs this is close to noise, but the direction is the same for both models and matches what Jonathan measured.
There’s no clear winner between Fable and Opus. Fable at medium found slightly more bugs from the list, Opus at high more bugs outside it, and it came out a quarter cheaper. I didn’t measure the kind of lead Jonathan saw (four bugs out of five versus two). So I take the advice in the conclusion, to use Fable for code reviews, with a grain of salt. On this task I wouldn’t pay extra for it.
One review isn’t enough. None of the fifteen runs found more than six of the eight bugs, and results for the same model varied up to threefold between runs. Three Sonnet runs and three Opus runs at high together covered 7.5 points out of 8, plus the reader bug. A Sonnet run costs about a third of an Opus run, so my advice is: run the review several times and with different models, instead of paying for one expensive run at full effort.
Mythos and security
Mythos is the strongest Claude for cybersecurity. In Anthropic’s test of rediscovering known vulnerabilities, it found ten percent more than Opus 5.5. But Anthropic itself admits in a note that in its own tests, vulnerability hunting is roughly on par with Opus.
Fewer sandbox escapes. In a test where the model tries to get hold of credentials outside its environment, Mythos 5.2 did so in 3 percent of scenarios, Mythos 5.1 in 21 percent. Opus 5.5 is on par with the new Mythos.
Anthropic deliberately held back a few capabilities. Optimization of compute kernels for accelerators and the design of language model architectures are at Opus level in Fable 5.2. Anthropic doesn’t want the model to speed up the development of further AI. This doesn’t affect ordinary programming or machine learning.
In conclusion: what to take away
For everyday programming and office work, stay with Opus 5.5. Anthropic recommends that too, and the first tests confirm it: on most tasks it’s a tie at half the token price.
Take Fable 5.2 for long, independent tasks. Code reviews, big migrations, tasks that run for hours, dozens of agents at once, complex problems with a clear measure of success. That’s where it adds the most.
In Claude Code, try it as an advisor. With the command /advisor fable (or with the model’s full name claude-fable-5-2) you let Opus 5.5 do the work, and Fable is consulted only when Opus is stuck: before choosing an approach, on a recurring error, or before declaring the work done. You can also ask for a consultation yourself in the prompt. It works out cheaper than running Fable on everything. Just beware: every consultation rereads the entire conversation so far, so in a long session the costs add up. On a subscription, Fable as an advisor is billed the same as Fable itself, and the feature is still experimental.
Set medium or high. According to the first tests, max doesn’t pay off even on the hardest tasks.
On a subscription, watch the limit. Fable consumes at most half of the weekly limit, and anyone who lets it run on everything will burn through it quickly.
Mythos is for security firms and labs. Everyone else won’t get it and doesn’t need it.
For me, this is the first Fable where it’s clear why it exists. Version 5.1 dropped below Opus in current measurements, and you were paying for the name. Version 5.2 is a notch higher and, thanks to medium effort, perhaps even reasonably priced. I just wouldn’t treat it as a replacement for Opus, more as a specialist you call when Opus isn’t enough.
Sources: Anthropic’s announcement of November 9, 2026 and the system card for Fable 5.2 and Mythos 5.2, Artificial Analysis measurements (index version 5.0.1, cost per task for Fable 5.2 not yet published), the Limited Edition Jonathan test (the author had advance access from Anthropic), Claude Code documentation on the advisor, the author’s own test, The Next Web, 9to5Mac. Anthropic’s table and the case studies were measured by the vendor. Vals has not yet measured Fable 5.2. Information valid as of November 9, 2026. The text was written with the assistance of Claude Opus 5.5, a model from the same company whose product I’m writing about.
