Home / Numbers

Numbers

How to get the most out of Fable 5.2 and Opus 5.5 in November 2026

On the new models you can no longer turn thinking off, and effort is the only lever left, so the choice has changed again. I’ll show you which one to start with, how much effort to give it, and when to switch to the other, with the numbers

Danilo Giudice · November 11, 2026

Type

Numbers: a myth busted with data

Time

18 min read

Level

Intermediate

What you’ll get

• Which model to start with for each task
• How much effort to give and when to move up to Fable 5.2
• What the cache and a mix of models cost

For every task you have to choose two things: the model and its effort. Addy Osmani explains how in his post “Which Claude model should you build with?”, from November 9, 2026. Here’s an example from the post:

Per token, Fable 5.2 costs twice as much as Opus 5.5 (a token is a small piece of the text that goes into and comes out of the model). Yet on FrontierCode 2.0, a set of tests that is the same for every model (a benchmark), Fable 5.2 at high effort scored 45.3% and Opus 5.5 at max scored 45.5%, with Fable at about half the cost per task.

The spoiler: if you make it to the end, you’ll know which model to start with for each job, and in what order to raise effort and model when the result isn’t good enough. And you’ll take home a file ready to copy, which has Haiku 5.5 read the logs instead of the expensive model.

I work with Claude Code every day, and I’ve found that the best compromise, for almost everything, is Opus 5.5 at medium. Handing the execution to Sonnet 5.5, though, saves tokens and speeds up the work: Sonnet 5.5 costs half as much as Opus 5.5 per token and is 30% faster than Sonnet 5. I use Fable 5.2 for the hardest jobs, at medium (I’ll show you why later on).

A note on sources: the post calls these models “ours,” so I cross-checked prices and limits against the Claude API reference, and the benchmarks are still Anthropic’s.

Start with Opus 5.5, at medium effort#

Let’s get to the point. The model to start with is Opus 5.5, with effort at medium: it’s the Claude Code default, and per token it costs half as much as Fable 5.2.

Effort is the parameter that sets how much work the model does before it returns the answer: how many thinking tokens it generates (the intermediate text before the answer, which Anthropic calls reasoning), how many tool calls it makes, and how many checks it runs. There are five levels: low, medium, high, xhigh, and max.

In practice, it’s a dial between speed and accuracy. The higher you turn it, the more work the model does, and the more you pay in tokens and in waiting time. At low it makes fewer tool calls and gives shorter answers; at high it makes more of them and checks its own work more.

Keep this in mind, because the higher the effort, the longer you wait: with a lot of thinking, the execution comes only after it. On some tasks you don’t need that thinking, and it’s just a waste of tokens and time.

The four models and their prices#

All four work with a context (everything the model receives in one request) of up to 1 million tokens. Each response, on the other hand, can be at most 128,000 tokens long, thinking included: about an eighth of the context. They differ in price and speed.

Price list

Fable 5.2: twice the price of Opus 5.5

Dollars per million output tokens. Input: 8, 4, 2, and 0.10.

Fable 5.2

40.0

Opus 5.5

20.0

Sonnet 5.5

10.0

Haiku 5.5

0.5

Haiku 5.5 costs a twentieth of Sonnet 5.5.

Source: Claude API price list, November 2026

Claude Mythos 5.2, for cybersecurity and life sciences research, is only available through Anthropic’s verification programs, so it’s not part of this comparison.

Which model for which task#

How do you choose the model? I look at two things: how hard the task is and how much a mistake costs. If the task is well written and a mistake shows up right away (a failing test, a wrong label), a small model is enough. If the task needs judgment, or the work is long and open-ended, you move up. The table below, taken from the post, puts this into practice, and two of its rows are about subagents.

Subagent: a separate instance of the agent, with its own context. The main agent hands it a task and gets back only the result.

It’s like asking a coworker to “find this file for me”: they do the search, you get only the answer, and your context stays clean.

When in doubt, Opus 5.5 at medium.

One warning from the post: a migration or a performance optimization can have a very clear spec and still need Opus 5.5, or Fable 5.2 for a major one. The same goes for a complex financial model or a document built on many sources: there you start with Opus 5.5, not Sonnet.

Effort first, then the model#

Raising the effort helps on hard tasks, which need more steps and more checks. It costs time and tokens, and it doesn’t give the model knowledge or abilities it doesn’t have.

How much does each level cost? For Opus 5.5 on SWE-bench Pro, a coding benchmark, the post gives these numbers, with high as the baseline.

Effort

From high to xhigh, 2.5 times the cost

Opus 5.5 on SWE-bench Pro, cost per task with high at 100. Approximate values.

low

33

medium

70

high

100

xhigh

250

For 1.4 more points; medium loses 2.5.

Source: A. Osmani, claude.dev, Nov 9, 2026

Going from high to xhigh, you pay 2.5 times as much for 1.4 points. Compared with high, low loses about 8 points and medium about 2.5, and medium costs 30% less: that’s why it’s the starting point.

RULE: before you switch models, raise the effort by one level. Past high, though, try the next model up at a lower effort, because one more level can cost as much as a bigger model.

{
  "model": "claude-opus-5-5",
  "max_tokens": 16000,
  "output_config": { "effort": "high" },
  "messages": [{ "role": "user", "content": "…" }]
}

The biggest model at max doesn’t always win#

Many people find this assumption reasonable: “the most capable model costs more, but at least the result is the best, so I’ll set it to max and stop worrying about it.” In reality, it’s a trap.

In the end, what you pay is the cost per finished task. The price per token is like the price of gas per gallon: what matters is how much you spend to get there, and that also depends on how many gallons you burn.

The result? On FrontierCode 2.0, Fable 5.2 at high ties Opus 5.5 at max, at about half the price. On Terminal-Bench 3.0 it goes the other way: Opus 5.5 at high narrowly beats Fable 5.1 at max, with half the tokens. I’ll be honest: these numbers come from the people who sell the models, and the Terminal-Bench comparison is about Fable 5.1, not 5.2 (the post takes it from “Spending your effort”, on the same blog). In both cases, the max level costs more and doesn’t give a better score.

For Fable 5.2, the best compromise is medium, according to the benchmarks in the Fable 5.2 launch (Anthropic, November 9, 2026). On Chartography, Fable 5.2 at medium scores 66.4%, against 64.4% for Opus 5.5 at max, at less than a tenth of the cost per task. On WANDR, again at medium, it matches the best score of Opus 5.5 with about 40% of the spend. So Fable 5.2 at medium uses far less than Opus 5.5 at max, with an equal or better result.

Benchmark

Fable at medium beats Opus at max

Chartography, no tools. Fable 5.2 launch, Anthropic.

Score

Max

Opus 5.5

64.4%

cost per task 100

Medium

Fable 5.2

66.4%3.1%

cost under 10

More points, under a tenth of the cost.

Source: Anthropic, Fable 5.2 launch, Nov 9, 2026

When you do the math, include the hardest tasks too, because they’re the ones that cost the most. On a 20-problem research benchmark, two problems, that is 10%, accounted for 43% of the spend.

Opus 5.5 for everyday work

• Start at medium and move up to high for large features and hard bugs.
• Always give it a way to check its own work, for example a test it has to pass.
• For computer use and image-heavy workflows, it’s the starting point, at medium.
• Thinking can’t be turned off: to spend less, lower the effort.
• If you need speed, the API has fast mode: the same model generates faster, at double the rate ($8 / $40 per million tokens).

Fable 5.2 for the hardest jobs

• Save it for jobs where Opus 5.5 at high isn’t enough and for long unsupervised sessions: large migrations, architecture, research, and quantitative analysis.
• Effort: I start at medium, which is already the default in Claude Code (on the API the default is high). Go higher only where you’ve measured a gain.
• Give it the whole task at the start, and expect a single request to take many minutes: have the response sent in pieces as it’s generated (streaming), and show whoever is waiting that the work is moving forward.
• Don’t edit messages you’ve already sent: if you change anything before a thinking block, the API returns a 400 error (this is preserved thinking).
• It generates output up to 30% faster than Fable 5.1. And if it coordinates other agents, put cheaper subagents under it (we’ll get to that shortly).

When it’s not enough, change one thing at a time#

Escalation

Everything at low, failed tasks at high

Opus 5.5 on a subset of SWE-bench Pro. Approximate values.

Tasks passed

Before

All at high

95.3%

$0.29 per task

After

Low, then high

97.0%1.8%

$0.17 per task

About 40% lower cost.

Source: A. Osmani, claude.dev, Nov 9, 2026

Context costs money, even in the cache#

Every turn of a conversation sends the whole context back to the model. So in long sessions, most of the input is billed as cache reads.

Prompt cache: the opening part of the request, identical to the one in previous turns, which the service keeps aside and bills at a reduced rate. Reading from it is called a cache read.

On Opus 5.5 and Fable 5.2, a cache read costs $0.20 per million tokens. A turn with 20,000 cached tokens costs about $0.004, and one with 150,000 about $0.03: 7.5 times as much. A hundred turns come to about $0.40 versus about $3.

Fable 5.2 and Opus 5.5 have the same cache read rate. In a session that’s mostly cache, the difference between the two is in the uncached input and in the output, where Fable costs twice as much.

What it costs to resume after an hour

In my Claude Code setup, the cache lasts an hour. If I resume a job after that, the first request writes the whole context to the cache again, and on the API a cache write that lasts an hour costs twice the normal input price: on Opus 5.5 that’s 40 times a cache read. With 150,000 tokens of context, you go from about $0.03 to about $1.20, just to start again.

Cache

Resuming after an hour rewrites the cache: 40 times the cost of a read

40×

$1.20Expired cache

$0.03Warm cache

150,000 tokens on Opus 5.5. My calculation from API list prices

That’s why I added a cache indicator to the Claude Code status line in my Warp terminal. While the cache is warm, it shows how many minutes it has left (cache 48m, in yellow when it’s about to expire); once it’s frozen, it shows a snowflake and the tokens the next request will have to write again (cache ❄ +150k). That way I know what resuming a job will cost me before I even type the first message.

In practice: keep the expensive model’s context for decisions, and have subagents do the long reading of files and logs. I wrote about how much the Claude Code context weighs in “Claude Code hygiene”.

Mixing models: when it pays off and when it doesn’t#

The post describes three cases, and only mass delegation has measured savings. Let’s go through them piece by piece, and at the end I’ll tell you how I do it.

Small subagents for work you can check at a glance

Searching files, running tests, reading logs: if a mistake shows up right away, Haiku 5.5 or Sonnet 5.5 is enough. Code changes and the decisions that matter stay with the main model. How to define subagents is in the Claude Code documentation.

---
name: log-reader
description: Reads test output and logs, and reports each failing case. Use after a test run.
tools: Read, Grep, Glob, Bash
model: haiku
---

Read the logs you're given. For each failure, report the file, the test name and the first error line. Don't edit any files.

Mass delegation, if the work can be split

Delegation

Opus 5.5 coordinating 25 Sonnet 5.5 agents spends a third less

−33%

100Opus alone

67Opus + 25 Sonnet

Internal benchmark, about 22 million tokens. A. Osmani, claude.dev

The benchmark is internal: searching for defects in about 22 million tokens of code, 22 times a model’s maximum context, with the same score as Opus 5.5 alone. It doesn’t apply to steps that depend on each other, or to work that fits in a single context. The tool the post uses is the multiagent orchestration in Claude Managed Agents.

opusplan and advisor: measure first

In Claude Code, opusplan has Opus do the planning and Sonnet write the code, which is the opposite of what I described above: try it on your own tasks before you make it your default. The advisor tool (in beta) pairs a cheap executor with a stronger advisor, and you pay for almost all the tokens at the executor’s rate. Anthropic’s cost guide, though, admits that no pair clearly beat the executor on its own.

How I do it: octopus

For long jobs in Claude Code I use octopus, a Claude Code command I built that splits the work across three models. Opus 5.5 plans and decides. Sonnet 5.5 builds, runs the tests, puts the pieces back together, and reviews the work with a clean context. Haiku 5.5 runs the mechanical subtasks, and when a subtask is harder, the same executor starts again on Sonnet 5.5.

The post recommends keeping code changes on the main model. I delegate them, but only when Opus 5.5 has already planned them, with the files to touch and the verification criteria written down, and with a reviewer that checks the result.

One last thing. If the routing rule is simple, for example one model for each type of step, let your code pick the model rather than asking another model to.

Before you migrate, six things to check#

If you move code written for the previous models onto these ones, some requests that used to go through now return an error.

• Fable 5.2, preserved thinking. A 400 error if anything changes before a thinking block (system prompt, tools, earlier messages), unless you ask for it to be dropped. Keep the history append-only: add to it, don’t rewrite it.
• Opus 5.5 and Fable 5.2, thinking. An error if you try to turn it off: adjust the effort instead. Sonnet 5.5 has thinking on by default; on Haiku 5.5 you can turn it off, but only at high effort or lower. Read the response blocks by type.
• Sonnet 5.5, Opus 5.5, and Fable 5.2, tool_choice. A 400 error with any or tool: use auto and tools with strict: true, and write in the prompt when to use them.
• All four, computer use. It only works with computer_toolset_20260801, on Claude API and Claude Models on Google Cloud: update the tool.
• From Haiku 4.5 to Haiku 5.5. A 400 error with non-default temperature, top_p, or top_k, or with a final assistant message, and budget_tokens is gone: switch to an effort level, remove those parameters, and end messages with a user turn.
• The safety classifiers. They mostly flag requests about cybersecurity and biology. In Claude Code, a flagged request can be retried on an older model, with a warning: Opus 4.8 for cybersecurity, Opus 5 for biology. Build every request for the strictest model, and plan for the fallback.

Measure on your own work#

Benchmarks tell you where to start. You make the final choice by measuring on your own tasks, with the post’s four-step method:

1. Take a sample of real tasks and write an outcome check for each one: a passing test, a closed ticket, a correct row count.
2. Run each candidate at two or three effort levels, each in its own session, and record the cost per task from the usage field of each response.
3. Plot score against spend. Keep a multi-model setup only if it beats every single-model point.
4. Run the winner in shadow on a slice of real traffic before you switch everything over.

If you have five minutes right now: take a task from your list, run it on two models with /model, and compare what /usage reports.

The moral#

So? The moral? Start with Opus 5.5 at medium, hand the execution to the smaller models, and move to Fable 5.2, at medium, when Opus isn’t enough. The end.

I’ll repeat the rest of the week for you, parrot-fashion

I keep up with AI, so on Monday morning you know what to try and what to ignore, with sources you can check.

Your email

Email me on Mondays

Leave this field empty

One email every Monday morning, in Italian. Unsubscribe with one click. Privacy

Prefer Telegram? News and tutorials go up there, in Italian, as soon as they come out.

Notify me on Telegram