On 1 September Anthropic released Claude Fable 5.1, the newest model in its premium tier at $10 per million input tokens and $50 per million output, and it went straight to the top of Artificial Analysis’s intelligence index. On 22 September Claude Opus 5.5, at $4 and $20, took the top spot back. Fable 5.1’s lead lasted 21 days.
It’s the second time this summer the cheaper model has caught the premium one, and the pattern matters more than either release, because it changes what the premium actually buys. The numbers behind the latest round also come with a caveat that most launch coverage skipped: some of them may be memory.
Twice in four months
Anthropic launched the Fable tier on 9 June with Fable 5, which it called more capable than “any model we’ve ever made generally available”, priced at twice its Opus models. What followed:
- 24 July. Opus 5, at $5 and $25, edged past Fable 5 on Artificial Analysis’s index, 61 to 60, at 26% lower cost per task, 45 days after Fable 5’s launch.
- 1 September. Fable 5.1 took the lead back, scoring 66 against Opus 5’s 63.
- 22 September. Opus 5.5 overtook it, 58 to 53, at a third of the cost for the same score. Fable 5.1 had led for 21 days.
The index was revised along the way, so a score only means something next to the others measured at the same time; 58 today isn’t lower than 66 in September. What carries across is the order, and the lead has changed hands three times since July.
Two rounds is not a law, and Anthropic sets both prices, so the pattern may be as much pricing strategy as progress. But for anyone buying, the practical conclusion is the same: the premium tier’s lead is measured in weeks, and its price is not.
What Opus 5.5 changed
The price. Against Fable 5.1, Opus 5.5 is two and a half times cheaper per token on everything except cached context, where the two are nearly level:
| Per million tokens | Opus 5.5 | Fable 5.1 |
|---|---|---|
| Input | $4 | $10 |
| Output | $20 | $50 |
| Cache read | $0.20 | $0.25 |
Anthropic’s own claim is that it “performs at the level of Claude Fable 5.1 on most work”, while costing 40% less to run than Opus 5 on typical workloads. The customer results in the announcement are almost all about doing the same work in fewer steps and fewer tokens. They come from early-access customers chosen by Anthropic, so they describe a direction rather than a measurement.
The numbers, and whose they are
Anthropic’s own. In the system card’s summary table, Opus 5.5 beats Fable 5.1 on every benchmark listed, for example 66.4% against 55.8% on Terminal-Bench 4.0 and 89.9% against 81.2% on SWE-bench Pro. Every one of those scores was run at max effort, averaged over five trials, while the 40% saving is about typical workloads. The headline scores and the headline savings describe different settings.
Artificial Analysis measures both models at every effort level and publishes cost per task at list prices:
| Effort | Opus 5.5 | Opus cost per task | Fable 5.1 | Fable cost per task |
|---|---|---|---|---|
| Low | 42 | $0.55 | 47 | $2.37 |
| Medium | 51 | $1.34 | 49 | $2.98 |
| High | 54 | $1.82 | 51 | $3.91 |
| Max | 58 | $5.98 | 53 | $7.63 |
Opus 5.5 at medium effort matches Fable 5.1 at high effort for about a third of the cost, and at max effort it posts the highest score the index has recorded. Fable is ahead only at the lowest setting.
Snorkel AI ran the models through 24 terminal-style coding tasks, 200 runs in all. Opus 5.5 passed 68% against Fable 5.1’s 49%, with a quarter of Opus’s failures down to output formatting in two tasks. Proximal’s FrontierSWE v2, 34 engineering and research tasks that take the strongest models close to 20 hours each, has Opus 5.5 at 62.3% against Fable 5.1’s 56.3%.
On that evidence the case is closed. It isn’t quite.
How much of it is memory
Endor Labs, which sells application security tooling, ran 179 real coding tasks drawn from code with a history of vulnerabilities, and checked every solve for signs the model had seen the answer before. It found 51 cases where Opus 5.5 appeared to recall the historical fix from training rather than work it out. Counting those, Opus 5.5 ranked first on secure code by more than 11 points. Removing them dropped it to third, and left Fable 5.1 ahead on functional correctness, 87.2% against 68.7%. It’s a vendor’s benchmark on a modest sample, and the fairest reading is not that Opus 5.5 cheats but that public code is exactly what models are trained on.
The benchmarkers have noticed. Two weeks before the release, Artificial Analysis raised the share of its index built on private questions or answers to 45%, up from 40%, to make it harder to game. Anthropic’s system card, likewise, notes where evaluations were written from scratch or kept private to avoid contamination.
That changes how to read Artificial Analysis’s table rather than overturning it. Opus 5.5’s lead holds on Artificial Analysis’s index, nearly half of which is now private, by five points. Where it deserves the most scepticism is exactly where it looks strongest: public coding benchmarks built from code that already sits on the internet. And on Endor’s decontaminated tasks both models did badly on security, about a third of patches passing, which echoes the Veracode finding in our evidence review. Neither makes review optional.
Same quality, a third of the cost
The index tables translate into money quickly. Take an agent that runs 1,000 tasks a day of the kind the index measures. At the matched score of 51, Opus 5.5 at medium effort costs about $1,340 a day and Fable 5.1 at high effort about $3,910: roughly $77,000 a month apart for the same measured quality. Your tasks won’t cost what the index’s tasks cost, so treat the ratio as the finding and the dollar figure as an illustration.
Speed follows the same shape. Dividing Artificial Analysis’s output tokens per task by each model’s measured output speed gives a rough time per task, counting generation only:
| Effort | Opus 5.5 | Fable 5.1 |
|---|---|---|
| Low | 2.1 min | 6.5 min |
| Medium | 5.5 min | 8.3 min |
| High | 7.3 min | 11.3 min |
| Max | 20.9 min | 18.3 min |
At the matched score, Opus 5.5 finishes in about half the time. The exception is max effort, where it writes about 50% more tokens than Fable and ends up slower despite generating faster, so the top setting suits background work rather than anything a user waits on.
Where Fable 5.1 still earns its price
Three jobs, on current evidence:
- First-attempt correctness on sensitive code, per Endor’s decontaminated results.
- Numerical reasoning over documents. On OfficeQA, a Databricks benchmark of questions over US Treasury documents, Anthropic’s own card has Fable 5.1 ahead, 80.2% against 78.9%, and 69.0% against 67.7% on the harder subset.
- The cheapest, fastest setting. At low effort Fable scores 47 against Opus’s 42. Opus at medium still beats Fable at low for less money, so this one is usually solved by raising the effort rather than switching model.
What changes when you build on it
Three details in the system card matter more to an integration than any benchmark.
Thinking can’t be switched off. Opus 5.5 is offered with thinking enabled only, so the effort level is the only dial for cost and speed. Pipelines that ran earlier models without thinking for short, cheap calls need another plan for them: a low effort setting, a smaller model, or a decision model inside the agent loop.
Some requests are answered by an older model. Requests that Anthropic’s classifiers flag as cybersecurity misuse fall back to Opus 4.8; some biology and frontier-AI-development requests fall back to Opus 5; weapons requests and attempts to extract the model’s hidden reasoning are blocked outright. The blocks are transparent, and the fallbacks apply on Anthropic’s own products and for API developers who opt in. In Anthropic’s deliberately adversarial prompt-injection testing, 46% of coding scenarios ended up answered by Opus 4.8. Ordinary traffic won’t look like that, but a security product feeding the model exploit-adjacent code might, so measure how often your own requests trip the classifier.
Prompt-injection resistance is level with Fable. On Gray Swan’s indirect prompt-injection benchmark, run without Anthropic’s injection-specific protections, Opus 5.5 matches Fable 5.1 exactly: an attack succeeds 0.1% of the time on the first attempt and 1.0% within fifteen.
What the pattern means for choosing
If the premium tier’s lead lasts weeks, choosing a model is less about picking the best one and more about making the choice cheap to change. That is how we’d approach it:
- Build to switch. The model sits behind an interface, so moving from Fable to Opus, or down to the next tier, is a configuration change and not a rewrite. The next move may come from further down: Anthropic’s price list already includes a Sonnet 5.5 at half Opus 5.5’s price.
- Decide on your own tasks. An evaluation set from the product’s own work, as we set out for Jev, run against two or three models at two or three effort levels, compared on quality, cost per task and latency. Private by definition, so nothing on it has been memorised.
- Pay the premium where it shows up in that test. For most agentic coding and knowledge work we’d expect Opus 5.5 at medium or high effort to win. Fable 5.1 keeps its place where first-attempt correctness on sensitive code matters more than price.
- Keep security review human, whichever model wrote the code.
Sources
- Anthropic, Claude Fable 5 and Claude Mythos 5 (2026)
- Anthropic, Introducing Claude Opus 5.5 (2026)
- Anthropic, System Card: Claude Opus 5.5 (2026), including Proximal’s FrontierSWE v2 and Databricks’ OfficeQA results
- Anthropic, Claude API pricing (accessed September 2026)
- Artificial Analysis, Opus 5: Fable 5 level intelligence at a lower cost per task, Claude Fable 5.1 tops the Artificial Analysis Intelligence Index, Claude Opus 5.5 takes the top spot, Opus 5.5 vs Fable 5.1 comparison and Announcing the Intelligence Index v4.3 (2026)
- Aich & Schlosser, Snorkel AI, Opus 5.5 vs Opus 5 vs Fable 5.1: coding benchmark results (2026)
- Compagna, Endor Labs, Opus 5.5: 6x cheaper and 2x faster than Fable 5.1 (2026)
- Our earlier posts: What the research says about AI-assisted development, Jev, and the case for models that don’t talk and Putting a decision model inside an agent loop