Blog · 2026-11-11

Fable 5.2 vs Opus 5.5: Fable Catches the Bugs Opus Misses, Opus Does Routine Work for Less

Model pages: Claude Fable 5.2 API · Claude Opus 5.5 API — pricing, specs and the playground

Fable 5.2 or Opus 5.5? Both are Anthropic models. Fable 5.2, released November 9, wins almost every benchmark Anthropic published, and in developers' public head-to-heads it caught bugs Opus missed. It also costs twice as much per token and thinks longer, so the same task cost 1.6 to 3.7 times as much. Here Fable 5.2 is $4.80 / $24 per 1M tokens and Opus 5.5 is $2.40 / $12. Use Opus for routine work and Fable for hard fixes and reviews.

Claude Fable 5.2 is the Fable generation Anthropic released on November 9, 2026, replacing Fable 5.1 at a 20% lower list price and with output up to 30% faster than 5.1. Claude Opus 5.5 came out on September 22 as the first Claude 5.5 model, and Anthropic pitched it as Fable 5.1-level work for most jobs at 40% less to run than Opus 5. On paper the two are identical: a 1M-token context window, up to 128K output tokens, text and image input, and thinking that is always on.

The questions people search for are which one is better, what a task costs, whether Fable burns more tokens, how fast each is, and which to pick for coding or writing. We did not run our own scoring for this piece. Instead we put the verifiable evidence side by side: Anthropic's launch benchmarks, the head-to-head tests and X posts developers published in the two days after launch (we went back to each original post to check the numbers), and real request timings for both models on our platform.

A word on who we are: we run apimodels.app, a platform where one API key calls Claude Fable 5.2, Claude Opus 5.5 and other image, video, audio and language models. Prices in this article are our list prices on November 11, 2026. Timing data comes from production calls on the platform, with our own accounts excluded and the sample size not disclosed. Third-party tests and user reports are credited by name, and their numbers are as published.

The short answer

On everyday coding tickets the two are close. The most thorough public comparison so far, from paddo.dev, ran each model 52 times on a real TypeScript codebase. On the first two groups of changes they passed exactly the same number of runs: 13 and 13, then 4 and 4.

The difference shows up on hard problems. In the same test, asked to review a fix that already passed its tests, Fable flagged the hole in it four times out of four and Opus once. Another developer had both hunt bugs in the same plugin: each found the same six, but Fable read more files and found one more error in a dashboard. The price is money and time. Fable costs twice as much per token, thinks longer and spawns more subtasks, so in public tests the same job cost 1.6 to 3.7 times as much and often took more than twice as long.

On apimodels.app, Fable 5.2 is $4.80 per 1M input tokens and $24 per 1M output, and Opus 5.5 is $2.40 / $12, both 40% below Anthropic's list, with cache reads at $0.12 on both. In one line: run Opus 5.5 as the workhorse and hand Fable 5.2 the hard bugs, code reviews and planning for big jobs. That matches Anthropic's own advice to start most coding and knowledge work on Opus 5.5.

What actually differs

• Price: Fable 5.2 is $4.80 / $24 per 1M tokens and Opus 5.5 is $2.40 / $12, so input and output are both double. Cache reads are $0.12 on both; cache writes are $6.00 vs $3.00.
• Default thinking depth: through the API, Fable defaults to high effort and Opus to medium. In Claude Code and the Claude apps both default to medium. Compare them without setting effort and Fable will naturally think, and spend, more.
• Specs: both have a 1M-token context, up to 128K output tokens, text and image input, and always-on thinking.
• Positioning: Anthropic says to start most coding and knowledge work on Opus 5.5 and keep Fable for the hardest, most open-ended technical work, or use it as an advisor to Opus or an orchestrator that hands tasks to smaller models.
• Parameters: Fable 5.2 drops temperature, top_p and top_k; we strip them automatically. If you tune style with those, check your outputs after switching.

Benchmarks: Fable leads almost everywhere, most of all on long tasks

On Anthropic's launch table Fable 5.2 beats Opus 5.5 on every row, but by very different margins. The widest is the Remote Labor Index, 41.3% to 21.3%, nearly double; it measures finishing real freelance-style projects end to end. Scientific terminal work on Terminal-Bench-Science is 74.6% to 58.7%, and reading charts without tools on Chartography is 73.4% to 64.4%.

The smallest gaps are on coding, which is what most people care about: FrontierCode 2.0 is 49.1% to 45.5% with both at xhigh effort, and FrontierSWE v2 is 69.9% to 62.3%. OSWorld 2.1's offline set is 89.3% to 87.2%, and that score is partial credit per step, not the share of tasks fully completed. Anthropic adds one more comparison: Fable at high effort scored 45.3% on FrontierCode, about the same as Opus at max effort (45.5%), at roughly half the cost per task. These are Anthropic's own numbers, a starting point rather than a verdict.

Coding: a tie on routine tickets, Fable ahead on hard bugs and reviews

The most careful comparison so far was published by paddo.dev on November 10. It replayed real, already-merged changes from a clean snapshot of a production TypeScript monorepo of about 3,700 files, ran each model 52 times in Claude Code at the default medium effort, and graded the runs with the tests that originally shipped. The first two groups were a tie. On the third group, bug reports that described only the symptom, Opus passed 27 runs by the tests and Fable 23.

The author then went through Fable's five failed runs and judged all five to be correct fixes. Fable had made one extra change the ticket did not ask for, and the tests only accepted the original fix. The human team had missed exactly that change and added it in a second commit four days later. When both models reviewed Opus's passing fix, Fable flagged the hole in all four runs and Opus in one. The author's advice: Opus for routine tickets, Fable for changes where a wrong fix is expensive (money, routing, anything that talks to another system) and for review.

The smaller single-person tests point the same way. Octavio Aranda had both models find, reproduce and fix bugs in one of his plugins. They found the same six; Fable read more files and caught one extra dashboard error, but took 6.6 minutes and about $2.78 against Opus's 2.9 minutes and about $0.76. When he ran each fix against the other model's tests, Opus's all passed and one of Fable's failed. He kept Opus as his default and calls in Fable when Opus gets stuck. Charlie Hills ran seven one-shot builds: Fable won almost all of them and cost two to three times as much per build. Peter Yang, who had early access, gave the models five informal tasks, among them a 3D kart racing game and a website redesign, and Fable won four of the five.

What this means in practice: if your pipeline only checks whether tests pass, Fable's edge can be undercounted, because the extra step it takes is sometimes exactly what the tests do not cover. If the ticket is clear and the tests are good, Opus delivers the same result for about half the money.

Cost per task: double per token, 1.6 to 3.7 times per task

Per token, Fable's input and output are exactly twice Opus's. Per task the gap is wider, because Fable thinks longer, writes more and is quicker to split work into subtasks. In public tests the same job cost 1.6 times as much on Fable (paddo.dev, 52 tasks, medium effort), 2.2 times (JAZII, one build at xhigh, $18 vs $8.20), 2.5 times (Charlie Hills, one build, $7.25 vs $2.88) and 3.7 times (Octavio Aranda's bug hunt, $2.78 vs $0.76). Addy Osmani, who works on Claude Code at Anthropic, also said Fable 5.2 is token-hungry: its per-token price is 20% below 5.1's, yet per task it costs about the same as 5.1.

So where does Anthropic's "about half the cost" come from? It compares Fable at high effort with Opus at max effort. To reach the same score Opus has to run at its highest setting and think for a very long time, and at that point Fable is the less expensive way to get there. Developers compared both at the same effort level, where Fable is naturally more expensive. Both claims are true; the question is whether you are pushing Opus to reach Fable's ceiling or giving both the same ordinary job.

One detail helps agent workloads: on our platform cache reads cost $0.12 per 1M tokens on both models. Take a typical agent turn with 80,000 tokens of cached context, 2,000 new input tokens and 1,500 output tokens. On Opus 5.5 that turn costs about 3.2 cents. On Fable 5.2 with the same output it is about 5.5 cents, 1.7 times rather than 2, because the large cached part costs the same. If Fable writes twice as much, 3,000 output tokens, it is about 9.1 cents, 2.8 times. What really widens the gap is how many tokens Fable writes, not how long your context is.

Speed: Fable is not slower per token, it thinks more

On real calls through our platform, answers of the same length take almost the same time on both models: for 1,000 to 2,000 output tokens the median is about 22 seconds against 21, and for 2,000 to 5,000 tokens about 41 against 40. Fable 5.2 has only been out for two days, so treat this as early data, but the direction is clear: it does not generate text more slowly.

The extra time comes from thinking and writing more. On Octavio Aranda's bug hunt Fable took 6.6 minutes and Opus 2.9. JAZII ran the same build on both at xhigh: Opus took about 15 minutes and Fable about 60, about 20 of them spent thinking before it started; the results were similar, with more detail from Fable. If you need Fable to be quicker, set its effort to medium or low and stream the output so the first words arrive much sooner.

Writing: opinions split

Feedback on writing contradicts itself. Dimitris Papailiopoulos, a researcher at Microsoft, said plainly on X that Fable 5.2 writes worse than Opus 5.5. One of Peter Yang's five tasks was a 600-word essay without filler; Fable won four of the five overall, but his post does not say which one Opus won, so the writing result is unclear. Anthropic's benchmarks do not measure writing on its own either.

For copywriting and editing we would start with Opus 5.5: it costs half as much and there is no evidence yet that Fable writes better. If tone matters, run three to five of your real prompts through both; with one API key it is a one-word model change.

Use both: Opus does the work, Fable checks it

The setup people discuss most on X is not choosing one but pairing them, and Anthropic now supports it directly: Fable 5.2 can act as an advisor that Opus or a smaller model consults on hard steps, or as an orchestrator that hands simple subtasks to smaller models. Charlie Hills priced one prompt three ways: Opus alone $2.88, Opus with Fable as advisor $3.88, Fable alone $7.25. One extra dollar bought most of Fable's benefit.

You can build the same pattern over the API: run the main loop on claude-opus-5-5 and send each finished change to claude-fable-5-2 for review, or let Fable break the job down and write the plan, then have Opus carry it out step by step. On apimodels.app both models use the same API key and switching is just the model field; for Claude Code setup see the Claude Code guide.

Which one to pick

• Everyday tickets, features and ordinary bugs: Opus 5.5. Same results in public tests at about 60% of the cost.
• Changes where a wrong fix is expensive (money, routing, external systems): Fable 5.2. It more often adds the step the ticket forgot.
• Code review: Fable 5.2. Reviewing Opus's fix it caught the hole four times out of four; Opus caught it once.
• Planning big jobs and long unattended agent runs: Fable 5.2. Its biggest benchmark leads are the Remote Labor Index and Terminal-Bench-Science.
• Latency-sensitive, high-volume calls: Opus 5.5. Fable is not slower per token, but it thinks longer per task.
• Copywriting and editing: start with Opus 5.5; it costs half and the writing verdict is split.
• A fixed budget but Fable's judgement on hard steps: Opus does the work, Fable advises or reviews.

On apimodels.app the model names are claude-fable-5-2 and claude-opus-5-5, available on the native /v1/messages endpoint and the OpenAI-compatible one, and failed calls are not charged. Endpoints and parameters are in the LLM docs; current prices are on the model pages for Claude Fable 5.2 and Claude Opus 5.5.

Related models

• Claude Fable 5.1: the previous Fable, $5 / $25 per 1M tokens here, slightly more than Fable 5.2, so new projects should go straight to 5.2.
• Claude Sonnet 5.5: $1.20 / $6 per 1M tokens, half of Opus 5.5 again, for high-volume coding where speed matters.
• Claude Haiku 5.5: $0.09 / $0.45 per 1M tokens, for high-throughput light work like classification and extraction, and a good subagent under Fable.
• GPT-6 Astra: OpenAI's flagship at $3.40 / $17 per 1M tokens, strongest on long-running terminal and ops agents.

For the same flagship-versus-workhorse question on the OpenAI side, see our GPT-6 Astra test: on the same everyday tasks Astra, at 3.4 times the price, tied GPT-6.1 Sol. The conclusion rhymes with this one: use the workhorse day to day and bring in the flagship for hard jobs.

Perguntas frequentes