Not a Winner, a Routing Rule: What I Learned Researching Claude Opus 5.5 vs Fable 5.1

Here is the whole argument up front. Stop asking which of the two models wins. Run Claude Opus 5.5 as your default, raise its effort before you touch the model picker, and move a task to Claude Fable 5.1 only when Opus 5.5 at xhigh fails the same check twice. That is Anthropic's own guidance S5S7, it is what the independent numbers show once you compare them on a single index version S9S10, and it is where the engineers who have run both for a week are landing S13S15S16. The detail I did not expect: the escalation only works in one direction. Fable 5.1 can read Opus 5.5's reasoning. Opus 5.5 cannot read Fable's S3. The routing rule is not a matter of taste. It is the shape of the API.

I started this as a normal comparison post. I wanted a table, a winner, and a recommendation. I ended up with a routing rule instead, because every source I checked kept pulling me back to three questions: which numbers are actually comparable, what a task costs rather than a token, and what happens to the conversation when you switch models. This is that research, including the number I misread first.

Why did the first scoreboard I read point the wrong way?

The first number I wrote down was 66. That is what Artificial Analysis gave Fable 5.1 at max effort on launch day, the highest score it had measured at the time S11. Three weeks later, the same firm said Opus 5.5 had taken the top spot with 58 S8. Read side by side, that looks like Fable ahead by eight points.

It is not. Since that first article, Artificial Analysis has revised its index. The current version, 4.3.2, is a ten-evaluation mix that now includes AA-Briefcase v1.1, GDPval-AA v2.1 and Terminal-Bench 4.0 S10. On that version, Fable 5.1 at max scores 53 S10 and Opus 5.5 at max scores 58 S9. The gap flipped direction because the ruler changed, not because either model did.

Anthropic's own launch posts have the same trap built in. The Fable 5.1 post reported 1853 on GDPval-AA v2 and 73.4% on CursorBench 3.2.0 S2. The Opus 5.5 post reports Fable 5.1 at 1735 on GDPval-AA v2.1 and 51.8% on CursorBench 4.0 S1. Even a row with the same name moved: OSWorld 2.0 with partial credit went from 77.9% for Fable 5.1 S2 to 80.7% S1, and I could not find a note explaining the re-run.

Two more details change what those tables mean. Anthropic ran Opus 5.5 at max effort for most rows and at xhigh for Terminal-Bench 4.0 S1, which is not the medium default you get out of the box S3. And Anthropic itself says the gap between the two models in its own use is "narrower than these scores suggest" S1.

The lesson I am keeping: before reading any benchmark number, pin three things. The benchmark version, the harness, and the effort level. If any of the three differ, the comparison is decoration.

What does each model cost, and why is price per token the wrong number?

List prices first, because they are the only numbers nobody disputes.

FIG. 01 · List price per million tokens on the Claude API · Opus 5.5 vs Fable 5.1, September 2026 S1S4

Opus 5.5 costs $4 per million input tokens and $20 per million output tokens, with cache reads at $0.20 and five-minute cache writes at $5 S1. Fable 5.1 costs $10 and $50, with cache reads at $0.25 and five-minute cache writes at $12.50 S4. So Fable is 2.5 times the price on input, output and cache writes, but only 1.25 times the price on cache reads S7. The reason is a deliberate pricing choice: Fable 5.1's cache read sits at 2.5% of its input price, well under the 10% multiplier most Claude models used S21, while Opus 5.5's moved to 5% S3.

Why does that one line matter so much? Because in long agentic sessions, cache reads are most of your input. Engineers in the Hacker News launch thread reported 95 to 99 percent of their input coming from cache, and one noted that at those ratios Fable 5.1 was already costing about the same as Opus 5 S14. Anthropic's own cost guide makes the same point: in a long Claude Code session, cache reads are the biggest line by token count, while output is the biggest line by dollars S7.

Here is the arithmetic, using the illustrative session shape Anthropic prices in that guide: 2 million cache-read tokens, 200 thousand fresh input tokens, and 60 thousand output tokens S7.

// Claude API list prices, USD per million tokens.
const PRICES = {
  "claude-opus-5-5": { input: 4, output: 20, cacheRead: 0.2 },
  "claude-fable-5-1": { input: 10, output: 50, cacheRead: 0.25 },
} as const;
 
type Usage = { cacheRead: number; freshInput: number; output: number };
 
function sessionCost(model: keyof typeof PRICES, u: Usage): number {
  const p = PRICES[model];
  return (u.cacheRead * p.cacheRead + u.freshInput * p.input + u.output * p.output) / 1_000_000;
}
 
// Illustrative Claude Code session shape (cache writes left out, as in the source).
const session: Usage = { cacheRead: 2_000_000, freshInput: 200_000, output: 60_000 };
 
sessionCost("claude-opus-5-5", session);  // 2.40
sessionCost("claude-fable-5-1", session); // 5.50, about 2.3x

Same tokens, 2.3 times the bill, not 2.5. The cheap cache narrows the gap on long, context-heavy runs, and the output price widens it on runs that think or write a lot S7.

But the two models do not use the same tokens, and this is where headline claims get slippery. Anthropic's 40% figure compares Opus 5.5 with Opus 5, not with Fable, and it is an estimate for typical workloads at default settings rather than a cut to the token price S7. Anthropic's Lydia Hallie summed up the pitch as "Feels like Fable" with faster output and a lower per-task cost than Opus 5 S22. Independent measurement adds a wrinkle: at max effort, Artificial Analysis counted about 119 thousand output tokens per index task for Opus 5.5 against about 78 thousand for Fable 5.1 S8.

Artificial Analysis also published the cleanest decomposition I found, for Opus 5.5 against Opus 5 at max. The extra tokens alone would have raised cost per task by about 80%, to $10.51. The 20% price cut brought that to $8.41, and the cheaper cache reads brought it to $5.98, within a few cents of Opus 5's $5.86 S12. One commenter in the launch thread put it more simply than any chart: it is only a price drop if price times tokens goes down S14. Another went back to the same data and worked out a median saving of about 38% across medium to max, once you treat max as the outlier it is S14.

What happens when you hold the index version fixed?

This is the chart I wish I had started with. Every point comes from Artificial Analysis Intelligence Index v4.3.2: same harness, same fallback setting, same day S9S10.

FIG. 02 · Artificial Analysis Intelligence Index v4.3.2 vs cost per task · snapshot 27 September 2026 S9S10

Read it left to right. Opus 5.5 at medium, its default, scores 51 for $1.34 per task. At high it scores 54 for $1.82. Fable 5.1 at max scores 53 for $7.63 S9S10. Opus 5.5 at high is one point better for about a quarter of the cost. Artificial Analysis reports that four of Opus 5.5's five effort levels sit on its intelligence versus cost frontier, costing less than or outscoring Fable 5.1, GPT-6 Astra and Opus 5 S8.

I only plotted Fable 5.1 at max. When I checked its lower-effort pages, some still showed numbers from the earlier index version, and mixing them in would have repeated the exact mistake from the previous section.

The right side of the chart holds the surprise. Opus 5.5 at max is by far its most expensive setting, and Simon Willison showed why in the most memorable test of launch week. His pelican-on-a-bicycle SVG prompt at max effort failed twice, both times hitting the 128,000-token output cap while the model was still reasoning, at $2.56 and nearly twenty minutes per attempt S13. He now suspects max is "effectively useless" S13. Fable 5.1 at max did not over-think the same prompt S13. Anthropic's docs describe the mechanism: at the same effort level, Opus 5.5 thinks more per turn than Opus 5, most of all at xhigh and max, so you should leave headroom in max_tokens S3.

One honest caveat. Artificial Analysis runs its own reference harness with Anthropic's default server-side fallback switched on S8S11. It is not your repository. It is the fairest public comparison available, and it is still a benchmark.

What are AI engineers reporting after a week with both?

Benchmarks tell you where to look. Practitioners tell you what breaks. I read the launch-week write-ups from engineers in the US and Europe, and a pattern shows up quickly.

The strongest endorsement came from Every's seven-day review S15. Kieran Klaassen moved his daily driver from Fable 5.1 to Opus 5.5 and puts it at roughly 90% of Fable's coding ability; on a shared Ruby task, Fable at high wrote 26 lines while Opus at extra high wrote 14 S15. Dan Shipper called it a "smaller Fable", faster and cheaper and therefore easier to use every day S15. Mike Taylor still reaches for Fable on the biggest problems, and in two of his timed tasks Opus 5.5 ran out the clock without producing the actual deliverable S15. Every disclosed that it had pre-launch access S15.

The most useful single data point came from a Hacker News commenter who happened to be testing a patch-review harness. Across 12 patches containing 14 known issues, Opus 5.5 found 8 for $15.40, Fable 5.1 found 7 for $66.34, Opus 5 found 6 for $58.19, and Sonnet 5 found 2 for $19.15, measured as equivalent API cost from a subscription S14. He called Opus 5.5 "both the best and the cheapest" in that run and flagged the small sample himself S14. The same thread held the clearest counterexample: a developer whose first Opus 5.5 code review cited line numbers that did not exist in the file, who then noticed the session was running at medium effort rather than the high he thought he had set S14. That is the default-effort change from the docs showing up in real life S3.

Simon Willison made Opus 5.5 his default in Claude Code S13. Zvi Mowshowitz, whose roundup pulls reactions from dozens of engineers, called it the most consistently positive set of reactions he has collected S16. Box CEO Aaron Levie reported 63% fewer tokens, 42% less verbosity and 30% faster runs than Opus 5 on enterprise knowledge work S16.

The dissent is worth reading closely, because it clusters. Yuchen Jin said GPT-6 Astra still felt better for coding and for a tricky research question S16. Jef Allbright described a writing task with several nested layers of meaning where Opus 5.5 worked faster but shallower, while Fable 5.1 understood it immediately S16. One user reported that roughly 1% of the time Opus 5.5 does something drastic, like crashing a staging server or killing running apps, even in auto mode S16. That sits awkwardly next to Anthropic's claims that Opus 5.5 is less likely than recent models to take hard-to-reverse actions and more resistant to prompt injection than Opus 5 S1S20. Anthropic also notes that Opus 5.5 often suspects it is being evaluated, which limits how far its own safety numbers generalize S1. And there is precedent for caution: Opus 5 also beat Fable 5 on many benchmarks, yet proved more limited on complex real-world problems S18.

Much of the enthusiasm is about communication, which sounds soft until you remember why people left Opus 5. Reviewers described Opus 5 as a chatterbox that ended tasks with a trail of loose ends S19. Every measured Opus 5.5's prose at a Flesch-Kincaid grade of 6.95 against 7.43 for Fable 5.1, the most readable model they had tested, while noting that it still tends to bury the point S15.

Where does Fable 5.1 still earn its price?

Anthropic's selection guide still lists Fable 5.1 as the pick for the highest available capability: agent sessions that run for hours, multistep deep research, and analysis carried through to a finished document, spreadsheet or deck S5. Its cost guide is more concrete: move up for long runs you will not supervise, for problems with no existing pattern in the codebase, and for large changes that coordinate many subagents S7.

The independent evidence points to the same corners. Zvi noted that Fable 5.1 takes all seven Vals professional rows along with MedCode, SAGE and both MLCR evaluations, a cluster he reads as expert-domain work graded purely on correctness S16. Every's advice lands in the same place: stay on Fable when the problem is too big to eyeball or the deliverable has to be right the first time S15.

Three cautions keep me from making this a clean split. First, Anthropic's internal HAProxy test cuts the other way on a long-horizon job: translating it from C to Rust, both models passed nearly all of its regression tests, but Opus 5.5 finished in 9.5 hours against 12 and cost 51% less S1. Long-horizon alone is not a reason to escalate. Second, in Anthropic's internal research-report test, where any invented figure or quote counted as a failure, 16 of 18 Opus 5.5 reports cleared the bar and none of Fable 5.1's did S1. That is a vendor-run test, but it complicates the idea that Fable is automatically the safer pick for correctness. Third, Fable 5.1 is not the permissive option for security or biology work. Opus 5.5 ships with the same class of safeguards as Fable 5.1, most cybersecurity tasks are routed to Opus 4.8 S1, and flagged biology requests go to Opus 5 S17. The looser sibling is Claude Mythos 5.1, the same model as Fable 5.1 with different safeguards, available only through trusted access programs S2S23.

Why is the escalation a one-way door?

This is the part of the research that turned a comparison into a rule.

Every thinking block records which model produced it. On the Claude API, Fable 5.1 and Mythos 5.1 can read thinking blocks from Opus 5.5, so a conversation that moves up keeps its reasoning. Opus 5.5 cannot read Fable blocks, so a conversation that steps back down continues without the previous model's reasoning. The API drops those blocks silently, the request still succeeds, and the dropped blocks are not billed S3.

FIG. 03 · The escalation rule as a ladder · raise effort first, escalate once, reasoning only travels forward S3S5S7

Three more constraints shape the rule.

• Keep the conversation append-only. For accounts created on or after August 31, 2026, the API rejects a request that replays a thinking block after anything before it has changed, including the system prompt, the tools or an earlier message. Anthropic recommends mid-conversation system messages instead of edits S3.
• Switching models costs a cache write. The cache belongs to the previous model, so the first turn on the new one pays the write price on the whole conversation. Compact first, or start fresh with a short written plan S7.
• The defaults are not equal. Opus 5.5 defaults to medium effort and Fable 5.1 to high S4S5. Comparing them at defaults compares two different amounts of thinking.

The good news for integration work is that the breaking changes line up. On Opus 5.5, thinking cannot be disabled and forced tool use returns an error, and both changes also apply to Fable 5.1 S3. One request builder can serve both models.

How would I encode this as an actual routing rule?

Here is the rule as code. It uses plain fetch against the Messages API so every field is visible, and it only uses parameters the docs confirm for both models: adaptive thinking, effort under output_config, and the default tool choice S3S4.

type Effort = "low" | "medium" | "high" | "xhigh" | "max";
type Model = "claude-opus-5-5" | "claude-fable-5-1";
type Rung = { model: Model; effort: Effort };
type Message = { role: "user" | "assistant"; content: unknown };
type Verdict = { ok: true } | { ok: false; feedback: string };
 
// Raise effort before switching models. Escalate once, after xhigh fails twice.
// No "max" rung: that is where over-thinking shows up first.
const LADDER: Rung[] = [
  { model: "claude-opus-5-5", effort: "medium" },
  { model: "claude-opus-5-5", effort: "high" },
  { model: "claude-opus-5-5", effort: "xhigh" },
  { model: "claude-opus-5-5", effort: "xhigh" },
  { model: "claude-fable-5-1", effort: "high" },
];
 
async function callClaude(rung: Rung, messages: Message[]) {
  const res = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "x-api-key": process.env.ANTHROPIC_API_KEY ?? "",
      "anthropic-version": "2023-06-01",
      "content-type": "application/json",
    },
    body: JSON.stringify({
      model: rung.model,
      max_tokens: 64000,              // headroom: thinking is billed as output
      thinking: { type: "adaptive" }, // the only mode on both models
      output_config: { effort: rung.effort },
      messages,
    }),
  });
  if (!res.ok) throw new Error(`Claude API ${res.status}: ${await res.text()}`);
  return res.json();
}
 
export async function runWithEscalation(
  task: string,
  verify: (reply: any) => Promise<Verdict>,
) {
  // Append-only history. Editing earlier turns invalidates bound thinking blocks.
  const messages: Message[] = [{ role: "user", content: task }];
 
  for (const rung of LADDER) {
    const reply = await callClaude(rung, messages);
 
    // Same safeguard class on both models: escalating a refusal buys nothing.
    if (reply.stop_reason === "refusal") return { status: "refused", rung, reply };
 
    // Ran out of room mid-thought: try the next rung from the same history.
    if (reply.stop_reason === "max_tokens") continue;
 
    // Pass content back untouched, thinking blocks included.
    // Fable 5.1 can read Opus 5.5 blocks, so the climb keeps the reasoning.
    messages.push({ role: "assistant", content: reply.content });
 
    const verdict = await verify(reply);
    if (verdict.ok) return { status: "done", rung, reply };
 
    messages.push({
      role: "user",
      content: `The check failed:\n${verdict.feedback}\nFind the root cause and fix it.`,
    });
  }
  return { status: "needs-human", messages };
}

A few decisions in there are deliberate.

• No max rung. Max is where over-thinking shows up first S8S13. I would reach for it by hand on a single hard problem, not bake it into an automated ladder.
• Refusals exit instead of escalating. Both models run the same class of safeguards S1, so sending a refusal up the ladder just pays Fable prices to get refused again. Handle it with Anthropic's fallback options instead S3.
• The verify function is the real work. Anthropic's cost guide argues that the cheapest fix is giving the model a way to check its own work, like a test, a build, or a script that calls the endpoint, before paying for more effort S7. The ladder is only as good as the check that decides when to climb it.

What does the side-by-side look like?

Which one should you reach for?

Opus 5.5 is the right default if:

• You supervise the work closely: feature work across a few files, debugging, code review with follow-up edits S7.
• Cost per task matters and you can set effort per job, medium for scoped work and high when medium stalls S7.
• You build things you look at, like interfaces, prototypes and visual tools S15.
• Humans have to read the output, like summaries, pull request descriptions and specs S1S15.

Escalate to Fable 5.1 if:

• Opus 5.5 at xhigh has failed the same check twice S7.
• The run is long and unsupervised, or the problem has no existing pattern in your codebase S7.
• The result is graded on expert-domain correctness more than on presentation S16.
• The deliverable has to be right the first time S15.

Neither model is the fix if:

• You keep hitting safeguard refusals on security or biology work. That is an access program question, not a model tier question S1S2.
• The job is a lookup, a log read or a file search. Anthropic suggests a smaller model for those subagents S7.
• You have not defined done or set a budget. Every found Opus 5.5 will happily take the whole afternoon if you let it S15.

What would I do differently next time?

Three things, in the order I would do them.

First, I would pin the index version, the harness and the effort level before writing down a single number. The 66 versus 58 misread almost made it into the first draft of this post, and a reader acting on it would have paid 2.5 times the token price for a model that scores lower on the current index.

Second, I would measure on my own tasks before quoting anyone else's percentages. Anthropic's advice here is refreshingly specific: run the same backlog task on each model, read turns, output tokens and cost from /usage, and repeat for three or four tasks before drawing a conclusion S7.

Third, I would set a stopping rule before any long run. Anthropic's playbook suggests saying what done looks like and when to stop and ask, in the prompt or in CLAUDE.md, and deleting old "think carefully" lines because the model already thinks before every reply S6. After reading about Every's timed-task failures S15, I treat that as mandatory, not optional.

Sources

1. S1Anthropic, "Introducing Claude Opus 5.5," September 22, 2026, anthropic.com
2. S2Anthropic, "Introducing Claude Fable 5.1 and Claude Mythos 5.1," September 1, 2026, anthropic.com
3. S3Claude Platform Docs, "What's new in Claude Opus 5.5," platform.claude.com
4. S4Claude Platform Docs, "Claude Fable 5.1" (model overview), platform.claude.com
5. S5Claude Platform Docs, "Choosing the right model," platform.claude.com
6. S6Addy Osmani, "Getting the most out of Opus 5.5 in Claude and Claude Code," claude.dev, September 22, 2026, claude.dev
7. S7Addy Osmani, "What a task costs on Opus 5.5," claude.dev, September 25, 2026, claude.dev
8. S8Artificial Analysis, "Claude Opus 5.5 takes the top spot on the Artificial Analysis Intelligence Index," September 22, 2026, artificialanalysis.ai
9. S9Artificial Analysis, Claude Opus 5.5 release page (all five effort levels, Intelligence Index v4.3.2), accessed September 27, 2026, artificialanalysis.ai
10. S10Artificial Analysis, Claude Fable 5.1 model page (max, default fallback, Intelligence Index v4.3.2), accessed September 27, 2026, artificialanalysis.ai
11. S11Artificial Analysis, "Claude Fable 5.1 tops the Artificial Analysis Intelligence Index," September 1, 2026, artificialanalysis.ai
12. S12Artificial Analysis on X, cost per task decomposition for Claude Opus 5.5 (max), September 2026, x.com
13. S13Simon Willison, "Claude Opus 5.5, GPT-6 Sol, GPT-6 Luna, and a new price war," September 22, 2026, simonwillison.net
14. S14Hacker News, discussion thread on Claude Opus 5.5 pricing and token use, September 2026, news.ycombinator.com
15. S15Katie Parrott, "Vibe Check: Opus 5.5 Is Pulling Our Codex Converts Back to Claude," Every, September 22, 2026, every.to
16. S16Zvi Mowshowitz, "Claude Opus 5.5 Should Raise Your Ambitions," LessWrong, September 26, 2026, lesswrong.com
17. S17The Decoder, "Claude Opus 5.5 matches Fable 5.1 performance at lower cost and promises less Claudish writing," September 2026, the-decoder.com
18. S18Techzine Global, "Claude Opus 5.5 beats Fable 5.1 at a much lower cost," September 2026, techzine.eu
19. S19PCWorld, "Claude Opus 5.5 promises to cut the chatter," September 2026, pcworld.com
20. S20Digital Trends, "Anthropic launches Claude Opus 5.5 with Fable 5.1 level performance at a 40% lower price," September 2026, digitaltrends.com
21. S21VentureBeat, "Anthropic's Claude Fable 5.1 and Mythos 5.1 arrive with a 75% cost reduction for Fable cache reads," September 1, 2026, venturebeat.com
22. S229to5Mac, "Anthropic upgrades Claude with new Opus 5.5 model, details here," September 22, 2026, 9to5mac.com
23. S23MacRumors, "Anthropic Launches Claude Fable 5.1 With Lower Costs and Fewer False Positives," September 1, 2026, macrumors.com

Written by

Syed Moinuddin

Full Stack Engineer.

Notes on AI tooling, agentic systems, and building things that survive contact with production.