Opus 5.5 vs Fable 5.1 vs Opus 5: the same tasks at a third of the cost

TL;DR I gave Opus 5.5, Opus 5, Fable 5.1, and Sonnet 5 the same four tasks in Claude Code, three runs each. Opus 5.5 cost 36% of what Opus 5 did and 33% of Fable 5.1, and finished in a third of Opus 5's time and just over half of Fable 5.1's. It also came in under Sonnet 5, which is cheaper per token but took three times as many turns. Raising it from medium to high changed nothing: for everyday work, leave it as it ships.

Update, November 1, 2026: since v2.1.311, ultrathink in the terminal raises its turn to xhigh on Opus 5.5 (it used to reason like high), without changing the session's effort.

Update, September 29, 2026: Sonnet 5.5 changes the Sonnet verdict. On this same harness it cost less than half of what Opus 5.5 did, with the same passes and in less time.

In the launch tip I re-priced my sessions at Opus 5.5's rates: same tokens, 44-46% less. But that only measures price. What I wanted to know is how many tokens each model spends on the same job, and the only way to see that is to put them to work.

What I measured

An 11-file PHP repo and four tasks from a normal working day. Each one has an automated check, written before anything ran:

Every run starts from a clean copy of the repo and is launched like this:

claude -p "<task prompt>" --model claude-opus-5-5 \
  --setting-sources project --strict-mcp-config \
  --no-session-persistence --dangerously-skip-permissions \
  --output-format json

--setting-sources project leaves out my user settings.json, and with it the per-model effort I've set, so each model runs at its own default: medium on Opus 5.5, high on the rest. I confirmed that before starting with the probe from the effort chain, and checked that my CLAUDE.md wasn't loaded either. --strict-mcp-config with no config gives every model zero MCP servers. The fifth contestant is Opus 5.5 with --effort high.

Cost, time, and turns come straight from each run's JSON: total_cost_usd, duration_api_ms, and num_turns. Cost is at API list price; I recomputed it by hand from modelUsage and it matches.

The whole benchmark (test repo, prompts, checks, harness, and all 60 runs with each one's diff) is in this zip, with a README to rerun it.

Results

60 runs: 5 configurations × 4 tasks × 3 repetitions. Medians per run, plus the total across each configuration's 12:

Opus 5.5 was the fastest on all four tasks and the cheapest on three; on the script it tied with Sonnet 5 ($0.19). The widest gap was the refactor: Opus 5 took 93 seconds and $0.53 at the median, Opus 5.5 took 21 seconds and $0.16.

Why a third: two effects that multiply

Against Opus 5, the saving has two sources:

• Rate. Opus 5's tokens billed at Opus 5.5 prices: $5.01 down to $3.34, 33% less. On my long sessions the rate alone gave 44-46%, because there cache reads weigh far more than in half-minute tasks.
• Tokens. At the same rate, what Opus 5.5 spent costs 45% less than what Opus 5 spent, because it gets there in half the turns (4 against 9.5). Every turn it skips is a re-read of the whole context you don't pay for.
• Both together: $5.01 down to $1.82, 64% less. They multiply (0.67 × 0.55), they don't add.

Against Fable 5.1 the rate does most of the work: both finish in 4 or 5 turns, but Fable charges two and a half times as much for input, output, and cache writes.

Sonnet 5: cheaper per token, not per task

Per token, Sonnet 5 costs half of Opus 5.5 ($2/$10 against $4/$20), and cache reads cost the same on both, $0.20. Opus 5.5 still came out 15% lower. It took 12 turns where Opus 5.5 took 4, and read three times as much from cache (a median of 372,000 tokens against 115,000).

Its one failure is a real bug: in one bug-fix run it wrote round($total / 1000000 * 100, 0, PHP_ROUND_HALF_UP) / 100, which floating point turns into 0.57 where 0.58 was due.

Raising it to high bought nothing

Opus 5.5 on high did exactly what it did on medium: 12 out of 12, a $0.16 median, two seconds slower. On tasks this size, medium isn't holding it back. Raise it only for the session that calls for it (claude --effort high), not as a standing setting. For a single hard turn, not even that: with ultrathink that turn runs at xhigh without touching the session's level.

What this doesn't measure

• Quality on hard tasks. Nearly everything passed (59 of 60), so this separates cost and speed, not reasoning. A bug that crosses modules or a long migration is a different test, and that's where higher effort levels should start to show. I tested that next, on tasks full of hidden edge cases, and they didn't show there either.
• Scale. Tasks of 11 to 99 seconds of API time, three repetitions, one day.
• A setup mistake of mine. In the rename and the refactor, the bug-task test was still failing in the repo. It hit every model the same way, and I scored those runs on their own task's tests. One Opus 5.5 run used the rename to fix the bug as well, unasked.
• API dollars. On a subscription you never see this figure; what you notice is how long your five-hour limit lasts and how long you wait.

Official docs: Model configuration · Pricing

What Opus 5.5 brings, and the two checks before you rely on it, are in Opus 5.5 in Claude Code. Why cache reads run the bill is in Fable 5.1. And which model I reach for beyond cost is in Sonnet 5, Opus 5 and Fable 5.

Requirements

• Claude Code v2.1.280 or later, with access to all four models. Every figure comes from that version, on September 23, 2026.