Skip to main content

Claude Fable 5.2 costs twice as much per token as Claude Opus 5.5, and Anthropic’s own launch page still tells most people to start on Opus. So the useful question is not whether Fable 5.2 is stronger. It is which jobs pay back the extra cost. I reviewed Anthropic’s launch results, the platform docs, the official demo posts and the first public side-by-side runs from developers. Six jobs clear the bar. A handful of others are better left on Opus 5.5.

The table compares the six jobs on the evidence that matters for the decision: the best measured gap over Opus 5.5, the effort level to start at, and what the extra spend buys you.

Use case Fable 5.2 vs Opus 5.5 (measured) Start at effort What the extra cost buys
Large Code Migrations FrontierSWE v2: 69.9% vs 62.3% high Fewer review rounds on long ports
Many-Agent Runs on One Goal Fermat formalization: done in 30 h vs 26% after 18 h high Runs that finish instead of stalling
Data Analysis That Ends in a Finished File AutomationBench: 51.4% vs 42.5% high Correct totals on messy data
Scientific and Numerical Code Terminal-Bench-Science: 74.6% vs 58.7% low to medium Opus-level reasoning at a fraction of the cost
Hardware and CAD Design BenchCAD 2.1: 83.5 vs 65.3 high Boards that work on the first build
Fable as an Advisor for a Cheaper Model Pairing, not a benchmark n/a Fable judgment on a Sonnet or Opus bill

1.Fable 5.2 Next to Opus 5.5 in One Minute

Claude Fable 5.2 is Anthropic’s most capable model open to every API customer, released on November 9, 2026. Its sibling, Claude Mythos 5.2, is the same model without the cybersecurity and biology safeguards, and only organizations in Anthropic’s verification programs can use it. Fable 5.2 has a 1M-token context window, 128k maximum output tokens and adaptive thinking that is always on. You steer it with five effort levels, from low to max, and the API default is high.

Anthropic's launch page for Claude Fable 5.2 and Mythos 5.2, dated November 9, 2026
Anthropic’s Fable 5.2 and Mythos 5.2 announcement. Source: anthropic.com

Price is the first filter. Fable 5.2 costs $8 per million input tokens and $40 per million output tokens, down from $10 and $50 on Fable 5.1. Opus 5.5 costs $4 and $20. Batch processing halves the Fable rate to $4 and $20, and fast mode doubles it to $16 and $80 for up to 2.5x faster output. On Pro plans and standard Team seats, Fable is included for up to 50% of weekly usage limits, and in Claude Code it can bill to usage credits depending on your plan.

Anthropic’s guidance is plain. Its model-selection docs say to start most workloads on Opus 5.5 and to move to Fable 5.2 only when Opus at higher effort still misses your bar. Its selection matrix lists Fable for “agent sessions that run for hours, multistep deep research, analysis carried through to a finished document, spreadsheet, or deck.” Every use case below is measured against that test: a documented gap over Opus 5.5 that is large enough to justify double the token price.

2.Large Code Migrations

A code migration is a long agentic job: the model reads a whole service, rewrites it in another language or framework, runs the tests and keeps going until the port works. It is the job where a model that stops early or loses the thread costs you the most, because the human picks up the half-finished work.

This is where Fable 5.2 has the best coding evidence. On FrontierSWE v2, an agentic coding benchmark, it scores 69.9% against 62.3% for Opus 5.5. On FrontierCode 2.0 it reaches 49.1% at xhigh effort, the highest of any released model Anthropic tested, against 45.5% for Opus. The cost detail matters more than the headline: at high effort, Fable scores 45.3% on FrontierCode, about level with Opus 5.5’s best, at roughly half the cost per task. Anthropic reports that a team of agents moved a production service from Python to Rust, and the new service starts about 26 times faster. Vercel says projects that took weeks with other models were finished and approved in a few days.

To run a migration, start at high effort and decide who owns the code before you write the prompt. Anthropic found that Fable 5.2 adds to the existing structure when the prompt says nothing about ownership, even when that duplicates code. When the prompt says the code base belongs to the model, it consolidated duplicated code in about 75% of runs, against under 10% without the line. Add this sentence only when you want that restructuring:

▣ Claude Code⌁ project⑂ main
You are the owner and long-term maintainer of this codebase, and its design is up to you.

The same test showed the cost of that sentence: output tokens rose by 70 to 80%, and the model made changes nobody asked for, mostly new tests and documentation. Leave it out when you want the smallest possible diff.

To check the result, read the diff, not only the summary. Anthropic warns that Fable 5.2’s closing pull-request summary often leaves out small changes. Compare the file list in the diff against the summary before you merge, and run the old and new test suites side by side.

3.Many-Agent Runs on One Goal

In a many-agent run, Fable 5.2 acts as the planner: it splits one large goal into pieces, starts subagents to work on them in parallel and checks their output. Anthropic names this orchestrator role as one of the model’s two main deployment patterns, next to the advisor role covered later.

This is the largest measured gap between the two models. A team of 1,000 Fable 5.2 agents formalized Fermat’s Last Theorem in 30 hours with minimal human intervention. An earlier formalization took 11 days with a purpose-built setup and human guidance. With the same 1,000-agent setup, Opus 5.5 had completed 26% after 18 hours and barely progressed by 30 hours. Fable also used about a third as many action tokens as the earlier effort, and its proof is seven times shorter. Other runs point the same way: an engineer built a prototype operating system with more than 1,000 subagents over eight days, and Uber ran a 10 to 12 hour security audit with about 170 reviewer agents.

The setup that matters is cost control. Subagents can account for a large part of what a session costs, so check which model your subagents use by default before you start. If a cheaper model can handle the pieces, point the subagents at it and keep Fable as the planner. If Fable starts more subagents than the task needs, rewrite the subagent tool description to state what a subagent adds to the session cost, when delegation is worth it and how to brief one. In Anthropic’s testing at high effort, a longer cost-focused description roughly halved the number of subagents.

At xhigh and max, Fable 5.2 also started using subagents to review its own work, which Fable 5.1 did not do on the same tasks. That is useful on a long unattended run, and it is another reason to watch the subagent share of your token bill.

To check a run, look at two numbers when it finishes: how many subagents it started and what share of the session tokens they used. If the subagents did most of the spend on simple tasks, move them to Sonnet 5.5 or Haiku 5.5 on the next run.

4.Data Analysis That Ends in a Finished File

This use case covers ambiguous, data-heavy work where the deliverable is a finished file: a SQL report, a reconciled spreadsheet, a memo or a deck. The risk in this kind of work is not a crash. It is a wrong number that looks right and travels into a decision.

Fable 5.2’s evidence here comes from customers who checked the numbers. In one Oracle test, SQL from two other models summed country-level amounts incorrectly and returned values five to eight times the expected totals, while Fable 5.2’s SQL was correct. Snowflake rated it the strongest model it has measured on a 103-task data-engineering benchmark. Box reports that it flagged a mismatch between salary deposits and a bank balance in a set of loan documents. On AutomationBench, which measures business workflows, Fable scores 51.4% against 42.5% for Opus 5.5. That is the job Anthropic’s selection matrix describes as “analysis carried through to a finished document, spreadsheet, or deck.”

To run it, give Fable the raw data, the exact artifact you want at the end and the questions it must answer, then run at high effort. Fable’s long reports can be dense, because the reader has not seen the tool calls behind them. Anthropic suggests adding a short instruction like this one, adapted from its prompting guide, when a person will read the final report:

▣ Claude Code⌁ project⑂ main
Write for an intelligent but low-context reader who has not seen your tool calls or files. Put the key points in the first few sentences, use plain words and full sentences, and keep bullets for lists of separate items.

In Anthropic’s agentic tests, that kind of text made final reports less dense and shortened sentences on workflow automation tasks.

To check the output, reconcile at least one total against a figure you already trust, such as last month’s revenue or a known row count. If the model reports a mismatch in the source data, as it did in the Box case, confirm it in the raw file before you correct anything.

5.Scientific and Numerical Code

This use case covers research code and hard reasoning with tools: speeding up a simulation, writing analysis code for an experiment, or working through a physics or math problem step by step. It is the area with the widest benchmark gaps, and it is also where Fable 5.2 can be cheaper than Opus 5.5 for the same result.

On Terminal-Bench-Science 0.1, Fable 5.2 scores 74.6% against 58.7% for Opus 5.5. The cost results are the surprise. On Humanity’s Last Exam with tools, Fable at low effort matches Opus 5.5’s top score at under one-tenth of the cost per task. On Chartography, Fable at medium scores 66.4%, above Opus 5.5 at max (64.4%), again at under one-tenth of the cost. On the applied side, Discovered Materials used it to make the phonon code in Quantum ESPRESSO about 36 times faster on average: its 13 benchmark cases dropped from 3.3 hours to under four minutes. Fable also largely completed a 2003 black-hole calculation on its own.

Run this work low first. Anthropic’s effort guide says low suits quick, well-specified tasks and medium suits interactive work, while max is “most reasonable” for open-ended problems such as scientific discovery and mathematics. A practical order is to try the question at low, move to medium if the answer is shaky, and reserve max for a problem with no known answer. At low and medium, Fable is more likely to end a turn before the work is done, so add Anthropic’s “finish the whole task” text for long runs. In replayed sessions at medium, it cut unfinished sessions by about half and raised output tokens by about 30%.

To check speedups, keep the original benchmark cases and run them before and after the change, comparing both the runtime and the numerical output. A faster simulation that drifts in its results is a regression, not a win.

6.Hardware and CAD Design

Hardware design here means the full path from a short spec to a working device: writing the specification, picking components, routing circuit boards, designing an enclosure for 3D printing and writing the firmware. It is a newer category for language models, and it is where Opus 5.5 trails Fable 5.2 by the widest margin on a design benchmark.

The best evidence is Anthropic’s own demo. From a one-paragraph prompt, Fable 5.2 designed three electronic devices with the board-design tool Diode: a home voice-assistant hub, a USB speakerphone and a handheld virtual pet. Each four-layer circuit board was ready for manufacturing in under a day, and all three devices worked without electrical modifications. On BenchCAD 2.1 at max effort, Fable scores 83.5 against 65.3 for Opus 5.5 and 44.4 for Fable 5.1.

To run a design job, write the spec as a short paragraph of requirements (what the device does, power source, size, interfaces) and let the model write the detailed specification from it, as the demo did. Start at high, which Anthropic recommends for hard agentic work, and step up to max, the level behind the BenchCAD score, only if your design reviews show a gain. A design mistake costs a board spin, which is far more than the extra token bill. Keep the model working inside your design tool so its output is a real board file, not a description of one.

To check a design, run the board tool’s electrical rules check before ordering, then build one unit and test every interface before you order more. “Worked without electrical modifications” is the bar the demo met. Use it as your acceptance test too.

7.Fable as an Advisor for a Cheaper Model

The advisor pattern keeps a cheaper model doing the work and lets it consult Fable 5.2 at hard decision points. The cheaper model, called the executor, decides when to ask; Fable reads the conversation, returns guidance and has no tools of its own. Anthropic’s launch page names this as one of Fable’s two main roles: Haiku, Sonnet or Opus can consult Fable 5.2 on harder problems.

It matters because most turns in a coding session do not need Fable-level judgment. Paying Fable rates only for the few consultations, and Sonnet or Opus rates for everything else, gets you part of the benefit for a fraction of the bill. I covered the setup, the official numbers and the costs in detail in our guide to using Fable as the Claude Code advisor, so here are the rules that are specific to Fable 5.2.

In Claude Code, pick Fable as the advisor with one command while your main model stays on Sonnet or Opus:

Text

/advisor fable

On the API, set the advisor tool’s model to claude-fable-5-2. Every executor model accepts it. The reverse is strict: a Fable 5.2 executor accepts only a Fable 5.2 or Mythos 5.2 advisor, and any other advisor returns a 400 error. Changing the advisor model also counts as an edit to tools, so make that change in new conversations. A Fable 5.2 advisor returns its advice encrypted, so code that reads the advice text needs the result-variant handling in the docs.

To check that it works, look for the “Advising” line in the Claude Code transcript and the advisor’s share of cost in /usage. If the advisor never fires, ask for it in your prompt before a big decision.

8.Where Opus 5.5 Still Wins

Fable 5.2 is not the better pick for every job, and the evidence for that is as clear as the evidence for its strengths. Anthropic calls Opus 5.5 the strongest daily driver and tells most people to start there. Six cases favor Opus.

Everyday coding and chat. At high effort and above, Fable 5.2 thinks before almost every reply, including a reply to a greeting, and a prompt line asking it to answer directly does not stop that at medium or above. For short, well-specified edits you pay for thinking you do not need. Opus 5.5 defaults to medium and costs half as much per token.

Code-built visual work where speed and cost matter. The first public side-by-side runs show the trade. Developer @EnvolDev ran the same 3D scene prompt on both models: Fable 5.2 cost $81.10 and took 1 hour 57 minutes, while Opus 5.5 cost $45.97 and took 3 hours 11 minutes. Developer @MrTacticalX got the reverse on time: Fable took 90 minutes and cost $57.87, against 68 minutes and $14.39 for Opus, about four times cheaper, though they said Fable’s sunset and night scenes were on another level. If a good-enough result is the goal, Opus is the better buy.

Claude Platform Docs model selection matrix recommending Fable 5.2, Opus 5.5, Sonnet 5.5 or Haiku 5.5 by need
Anthropic’s model selection matrix. Source: platform.claude.com

Expert knowledge work, on one measure. On the AA-Briefcase v1.1 benchmark, Fable leads on the rubric score (66.1% against 61.2%), but Opus 5.5 leads on the benchmark’s Elo rating, 1800 against 1785. When two measures of the same work disagree, the cheaper model is the safer default.

Computer use. On OSWorld 2.1, the gap is only 89.3% against 87.2%, and Anthropic’s selection matrix lists computer use under Opus 5.5. Fable 5.2 also rejects the older computer_20251124 tool everywhere except Amazon Bedrock, so older integrations need a migration first.

Security and some biology work. Fable 5.2’s safeguards block most cybersecurity tasks and most research biology tasks. Blocked cyber queries fall back to Opus 4.8 and blocked biology queries to Opus 5. Fable has about 55% fewer blocks than Fable 5.1, but for security engineering without a verification-program account, plan on Opus.

Routers that switch models mid-conversation. Only Fable 5.2 and Mythos 5.2 can read Fable 5.2’s thinking blocks. If your router moves a conversation from Fable to Opus 5.5, the reasoning from those turns is lost. Code that edits earlier messages also hits a new 400 error on Fable 5.2, which Opus-tuned code may never have triggered.

To check where your own line falls, run the same tasks on both models and record cost per task and pass rate. Anthropic’s own results show that effort can close much of the gap, so compare Opus at high or xhigh with Fable at medium before you decide.

9.Pick the Model and Effort per Job

The evidence points to a simple routing rule. Keep Opus 5.5 as the default for everyday coding, chat, computer use and security work. Move a job to Fable 5.2 when it runs for hours without a person watching, coordinates many agents, ends in a file where a wrong number is costly, or involves research code or hardware design. For everything in between, keep Opus or Sonnet as the main model and add Fable as the advisor.

Effort is the second lever, and Anthropic says it is often a better one than switching models. Start Fable at high, drop to medium wherever your results hold, and use low for research questions where Fable already matches Opus at a fraction of the cost. Keep xhigh and max for the hardest runs where you have measured a gain.

Claude Platform Docs Calibrate effort section describing low, medium, high, xhigh and max effort for Fable 5.2
Anthropic’s effort guidance for Fable 5.2. Source: platform.claude.com

Leave a Reply

Close Menu

About aiartimind

Hands-on guides to the AI tools creators actually use: Claude Code and coding agents, AI video and motion graphics, and AI agents that automate your work. Every workflow is tested before we publish it.