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
mediumtohighchanged nothing: for everyday work, leave it as it ships.
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:
| Task | The ask | Counts as done when |
|---|---|---|
| Bug | UsageCost::dollars() bills cache reads at the input rate and rounds with floor |
Suite green without touching tests/, plus 3 hidden cases (one is 0.575 → 0.58) |
| Rename | InvoiceMailer → ReceiptMailer across 5 files, file name included |
The old name appears nowhere and the factory returns the new class |
| Script | bin/usage-cost.php: read a JSONL, count each id once, print cost per model |
Exact output on a hidden 300-message file, different from the sample |
| Refactor | Pull the validation duplicated in 3 controllers into ContactNormalizer |
filter_var and ucwords appear once in src/ and the controller tests pass |
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:
| Model | Done | Cost | API time | Turns | Total |
|---|---|---|---|---|---|
Opus 5.5 (medium) |
12/12 | $0.16 | 20 s | 4 | $1.82 |
Opus 5.5 (high) |
12/12 | $0.16 | 22 s | 4 | $1.90 |
| Sonnet 5 | 11/12 | $0.18 | 31 s | 12 | $2.14 |
| Opus 5 | 12/12 | $0.44 | 61 s | 9.5 | $5.01 |
| Fable 5.1 | 12/12 | $0.48 | 38 s | 4.5 | $5.47 |
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. Reach for /effort high when a specific task calls for it, not as a standing setting.
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.
- 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.