Claude Sonnet 5.5 Review: Same Price, Far Less Waste

When Sonnet 5 launched in June, I wrote that it looked cheap at the token level but wasn't always cheap at the task level. I called it the junior engineer problem: a lower hourly rate doesn't help much if the work takes ten times longer.

Claude Sonnet 5.5, released on September 28, is Anthropic's answer to that problem. Mostly.

Most headlines skip this part: Sonnet 5.5 costs exactly the same per token as Sonnet 5. It's $2 per million input tokens and $10 per million output tokens. The tokenizer, cache prices and batch discount are all the same. If you were hoping for a smaller number on the pricing page, it isn't there.

What changed is how many tokens it burns to get the job done. That turns out to matter much more than the sticker price.

I've used it, gone through the benchmarks, and read the most useful outside review I could find. The best thing I found: next to Opus 5.5 it's very cheap, and it's still pretty good. That makes it an excellent general-purpose workhorse for the money. It isn't the model I'd reach for first when the coding gets hard, and Anthropic's pricing structure still has one gap I really wanted them to close.

Sonnet 5.5 at a glance

API price, input / output

$2 / $10

Per million tokens, unchanged from Sonnet 5

Intelligence Index, max effort

56

18 points above Sonnet 5, 2 below Opus 5.5

Cost per task, medium effort

$0.59

Under half of Opus 5.5's $1.34, and 41% less than Sonnet 5

Cache read price

$0.20

Per million tokens, the same as Opus 5.5

Released September 28, 2026 as claude-sonnet-5-5, with a 1M-token context window and up to 128K tokens of output. Index score and cost per task from Artificial Analysis; prices from Anthropic.

What Anthropic actually shipped

Sonnet 5.5 is the second model in the Claude 5.5 family, after Opus 5.5. Anthropic pitches it as the faster, cheaper complement to Opus. They say it's strongest at well-scoped everyday tasks, fixing bugs, and producing polished documents, slides and spreadsheets. It's available on Anthropic's API, AWS, Google Cloud and Microsoft's cloud.

Two things in the launch stood out to me.

First, Anthropic is unusually direct that Opus 5.5 is still clearly stronger at complex, open-ended work. Remember that line. It matters later.

Second, this is the first Sonnet to launch with Anthropic's cyber safeguards. Some higher-risk security requests will visibly fall back to Sonnet 5. If you're building security tooling, test your real workflows before you switch.

The pricing: what changed and what didn't

Per million tokens	Sonnet 5	Sonnet 5.5
Input	$2.00	$2.00
Output	$10.00	$10.00
Cache write (5 min / 1 hr)	$2.50 / $4.00	$2.50 / $4.00
Cache read	$0.20	$0.20
Batch input / output	$1.00 / $5.00	$1.00 / $5.00
Tokenizer	Same	Same

There's some backstory. Sonnet 5 launched at $2/$10 as introductory pricing through August 31, with an increase to $3/$15 scheduled for September 1. In August, Anthropic cancelled that increase and made $2/$10 the standard price. So if your budget still assumes $3/$15, the Sonnet line is a third cheaper than planned. But that happened to Sonnet 5 before 5.5 existed. Sonnet 5.5 didn't move the price again.

So where does "cheaper" come from?

Anthropic says Sonnet 5.5 costs up to 30% less per task because it uses fewer tokens and fewer tool calls. Vendors always say things like that, so I looked at independent numbers.

Artificial Analysis runs every model through the same set of evaluations and reports what one task costs at each effort level:

• Sonnet 5
• Sonnet 5.5

Low

$0.51

$0.4120% cheaper

Medium

$1.00

$0.5941% cheaper

High

$1.79

$1.0840% cheaper

Xhigh

$2.87

$2.745% cheaper

Max

$5.09

$7.6049% more

Source: Artificial Analysis, as of September 29, 2026. Hover or tap a bar for its Intelligence Index score.

Show the data

Effort	Sonnet 5 cost	Sonnet 5 score	Sonnet 5.5 cost	Sonnet 5.5 score	Sonnet 5.5 against Sonnet 5
Low	$0.51	24	$0.41	36	20% cheaper
Medium	$1.00	28	$0.59	41	41% cheaper
High	$1.79	32	$1.08	47	40% cheaper
Xhigh	$2.87	34	$2.74	52	5% cheaper
Max	$5.09	38	$7.60	56	49% more

This is the clearest example I can give. Sonnet 5.5 at medium effort scores 41 for $0.59 per task. Sonnet 5 at max effort scores 38 for $5.09. You get a better result for about 12% of the cost.

At high effort, 1,000 of these tasks cost about $1,790 on Sonnet 5 and $1,080 on Sonnet 5.5, while the score rises from 32 to 47. Same price list, a completely different bill.

Anthropic's launch customers report the same direction. Balyasny Asset Management said Sonnet 5.5 used about 121K tokens per answer where Sonnet 5 used 497K. Lovable reported a third fewer tool calls. CodeRabbit said Sonnet 5's "high token use" is gone. Anthropic picked these testimonials, so I weigh them less than independent data, but they agree with it.

The exception is max effort. Sonnet 5.5 at max costs 49% more per task than Sonnet 5 at max. It's far smarter (56 vs 38), but it isn't cheaper. Hold that thought.

My criticism: the cache pricing didn't move

In agentic work, a large share of what you pay for is cache reads: the model re-reading the same codebase, documents and conversation history on every turn.

With the 5.5 generation, Anthropic made cache reads much cheaper on its other models:

• Previous model
• Opus 5.5, Fable 5.1
• Sonnet 5.5

OpusOpus 5 → Opus 5.5

$0.50$0.20

FableFable 5 → Fable 5.1

$1.00$0.25

SonnetSonnet 5 → Sonnet 5.5

$0.20, unchanged

$0.00$0.25$0.50$0.75$1.00

Source: Anthropic API pricing. Cache reads cost 5% of the input price on Opus 5.5 and 2.5% on Fable 5.1; Sonnet 5.5 stays at the standard 10%.

Show the data

Model	Cache read per 1M tokens	Share of input price
Opus 5	$0.50	10%
Opus 5.5	$0.20	5%
Fable 5	$1.00	10%
Fable 5.1	$0.25	2.5%
Sonnet 5	$0.20	10%
Sonnet 5.5	$0.20	10%

So reading a cached token now costs exactly the same on Sonnet 5.5 as on Opus 5.5, even though Opus charges twice as much for input and output.

Here's what that does to an illustrative agent task that reads 2M cached tokens across its loop, sends 100K fresh input tokens and writes 50K output tokens:

• Cache reads (2M tokens)
• Fresh input (100K tokens)
• Output (50K tokens)

Sonnet 5.5Today's prices

$0.40

$1.10

Opus 5.5Today's prices

$0.40

$1.80

Sonnet 5.5If it had Opus 5.5's 5% cache rate

$0.20

$0.90

An illustrative example priced at Anthropic's API rates, not a benchmark. Cache writes are left out to keep it simple.

Show the data

Scenario	Cache reads	Fresh input	Output	Total
Sonnet 5.5, today's prices	$0.40	$0.20	$0.50	$1.10
Opus 5.5, today's prices	$0.40	$0.40	$1.00	$1.80
Sonnet 5.5, if it had opus 5.5's 5% cache rate	$0.20	$0.20	$0.50	$0.90

On paper Sonnet is half the price of Opus. In this example, Opus costs only 1.6 times as much. If Sonnet needs more output tokens than Opus for the same job, which the benchmarks suggest can happen, the gap shrinks further.

That's the change I wanted to see. I didn't need a headline cut to input pricing. I wanted a cache structure that fits how people actually use a Sonnet-class model: long agent loops, sub-agents, and huge cached contexts. Sonnet is the model you'd run inside those loops, and it's the one that didn't get the cache discount.

The best part: much cheaper than Opus, and pretty good

This is what stood out most when I used it. Sonnet 5.5 costs a fraction of what Opus 5.5 does, and for most of what I've used it for, it's pretty good.

The numbers agree. Per token it's half Opus 5.5's price: $2/$10 against $4/$20. Per task, at the same effort level, Artificial Analysis measured it cheaper at every setting except max:

• Opus 5.5
• Sonnet 5.5

Low

$0.55

$0.4125% cheaper

Medium

$1.34

$0.5956% cheaper

High

$1.82

$1.0841% cheaper

Xhigh

$3.46

$2.7421% cheaper

Max

$5.98

$7.6027% more

Source: Artificial Analysis, as of September 29, 2026. Hover or tap a bar for its Intelligence Index score.

Show the data

Effort	Opus 5.5 cost	Opus 5.5 score	Sonnet 5.5 cost	Sonnet 5.5 score	Sonnet 5.5 against Opus 5.5
Low	$0.55	42	$0.41	36	25% cheaper
Medium	$1.34	51	$0.59	41	56% cheaper
High	$1.82	54	$1.08	47	41% cheaper
Xhigh	$3.46	56	$2.74	52	21% cheaper
Max	$5.98	58	$7.60	56	27% more

At medium effort, a task costs $0.59 on Sonnet 5.5 and $1.34 on Opus 5.5, less than half. Even in the cache-heavy example above, where the gap is narrowest, Sonnet still costs about 40% less. Theo's review (more on that below) found a similar gap on a real codebase audit: about half of Opus's cost, with a slightly better score.

That's the appeal for me. For everyday work, "pretty good at less than half the price" beats "a bit better at twice the price" most of the time.

It's faster, too:

Sonnet 5

65 tokens/s

Sonnet 5.5

89 tokens/s

Opus 5.5

75 tokens/s

GPT-6 Sol

71 tokens/s

Source: Artificial Analysis, as of September 29, 2026.

Show the data

Model	Output tokens per second
Sonnet 5	65
Sonnet 5.5	89
Opus 5.5	75
GPT-6 Sol	71

The catch: Opus is still smarter, and sometimes the better deal

Opus 5.5 got cheaper as well, dropping from $5/$25 on Opus 5 to $4/$20, and it scores higher at every effort level. If you compare by result instead of by setting, the picture changes:

• Opus 5.5 at low effort (42, $0.55) slightly beats Sonnet 5.5 at medium (41, $0.59).
• Opus 5.5 at high (54, $1.82) beats Sonnet 5.5 at xhigh (52, $2.74).
• Opus 5.5 at xhigh matches Sonnet 5.5 at max (56) for less than half the cost ($3.46 vs $7.60).

• Sonnet 5
• Sonnet 5.5
• Opus 5.5

Intelligence Index

2030405060

Sonnet 5Sonnet 5.5Opus 5.5

$0.30$1$3$10

Cost per task

Source: Artificial Analysis, as of September 29, 2026. The cost axis is logarithmic.

Show the data

Model	Effort	Cost per task	Index score
Sonnet 5	Low	$0.51	24
Sonnet 5	Medium	$1.00	28
Sonnet 5	High	$1.79	32
Sonnet 5	Xhigh	$2.87	34
Sonnet 5	Max	$5.09	38
Sonnet 5.5	Low	$0.41	36
Sonnet 5.5	Medium	$0.59	41
Sonnet 5.5	High	$1.08	47
Sonnet 5.5	Xhigh	$2.74	52
Sonnet 5.5	Max	$7.60	56
Opus 5.5	Low	$0.55	42
Opus 5.5	Medium	$1.34	51
Opus 5.5	High	$1.82	54
Opus 5.5	Xhigh	$3.46	56
Opus 5.5	Max	$5.98	58

So "much cheaper than Opus" is true when you run both at the same setting, and that's why Sonnet 5.5 is my default. But if you need Opus-level results, Opus at a lower effort level gets you there for less than pushing Sonnet to its limit. And at max effort, Sonnet actually costs more than Opus.

One caveat on all of this: one benchmark suite has its own mix of tasks, and your workload won't match it exactly.

My take: a genuinely good general-purpose model

I like Sonnet 5.5. For everyday work it's the most useful Sonnet Anthropic has shipped. That covers writing, research, analysis, working through long documents, and answering questions about a codebase.

The numbers back that up. On the knowledge-work results in Anthropic's launch post, it's essentially level with Opus 5.5, and on computer use it's close behind (80.1% to 81.8% on OSWorld 2.1):

• Sonnet 5
• Sonnet 5.5
• Opus 5.5
• GPT-6 Sol

GDPval-AA v2.1

148718461844

AA-Briefcase v1.1

148318221811

1300140015001600170018001900

Source: Anthropic's Sonnet 5.5 launch post, which footnotes its GPT-6 Sol figures.

Show the data

Benchmark	Sonnet 5	Sonnet 5.5	Opus 5.5	GPT-6 Sol
GDPval-AA v2.1	1449	1844	1846	1487
AA-Briefcase v1.1	1359	1811	1822	1483

Anthropic also says it writes more clearly than the previous generation. That's one of the few launch claims the outside review I read agreed with.

It isn't perfect. On Artificial Analysis's factual-knowledge test (AA-Omniscience), Sonnet 5.5 scored 54% to Opus 5.5's 66%. For knowledge-heavy questions I can't easily check, I'd still verify the answer or use Opus.

Coding: very good, but not my first pick

I don't think Sonnet 5.5 is the best model for coding. It's a good coding model, and a big step up from Sonnet 5. But when a task is hard, ambiguous or involves design, I'd still reach for Opus 5.5 or Fable 5.1. That's my opinion. Here's the evidence on both sides.

• Sonnet 5
• Sonnet 5.5
• Opus 5.5
• GPT-6 Sol

Terminal-Bench 4.0

10.3%

70.6%

66.4%

not reported

CursorBench 4.0

34.1%

55.5%

57.8%

not reported

FrontierCode 1.1 (max)

42.4%

46.2%

54.4%

49.3%

Source: Anthropic's Sonnet 5.5 launch post. Anthropic didn't report GPT-6 Sol on Terminal-Bench or CursorBench, and footnotes some figures.

Show the data

Benchmark	Sonnet 5	Sonnet 5.5	Opus 5.5	GPT-6 Sol
Terminal-Bench 4.0	10.3%	70.6%	66.4%	Not reported
CursorBench 4.0	34.1%	55.5%	57.8%	Not reported
FrontierCode 1.1 (max)	42.4%	46.2%	54.4%	49.3%

Where it's strong

• Terminal-style agentic work. On Terminal-Bench 4.0, Anthropic reports 70.6%, up from Sonnet 5's 10.3% and ahead of Opus 5.5's 66.4%. Artificial Analysis's own run agrees on the ranking (below).
• Bug fixes and well-scoped tasks. This is exactly the area Anthropic says it's best at.
• Efficiency compared with Sonnet 5. It uses fewer tool calls, fewer shell runs and fewer wasted steps.

Sonnet 5

14.1%

Sonnet 5.5

63.6%

Opus 5.5

59.6%

GPT-6 Sol

43%

GPT-6 Astra

59.1%

Source: Artificial Analysis, as of September 29, 2026.

Show the data

Model	Terminal-Bench 4.0
Sonnet 5	14.1%
Sonnet 5.5	63.6%
Opus 5.5	59.6%
GPT-6 Sol	43%
GPT-6 Astra	59.1%

Where it falls short

• Harder coding benchmarks. It trails Opus 5.5 on CursorBench 4.0 and FrontierCode 1.1, and GPT-6 Sol on FrontierCode at max effort. Those are Anthropic's own published numbers.
• More thinking isn't always better. In the same table, Sonnet scores higher on FrontierCode at xhigh (52.1%) than at max (46.2%).
• Token appetite. Artificial Analysis measured about 193K output tokens per task at max effort, the highest it had seen. GPT-6 Sol used about 31K.
• Frontend and design. Anthropic says it has a sharp eye for design. The outside review I read found its layouts clearly worse than Opus 5.5 and Fable 5.1.
• Checking its own work at low effort. Anthropic's migration guide says that at low effort, Sonnet 5.5 sometimes reports a code change as done without running a check that exercises it. The guide includes a system-prompt paragraph to fix this. I appreciate the honesty, but it's the kind of thing you want to know before running it unattended.

General intelligence and coding performance are different things. GDPval-style benchmarks reward knowledge work. Hard coding rewards sustained judgment across many files and many decisions, and that's where Opus's advantage shows up.

The outside review worth watching: "delegate, don't select"

The most useful outside take I've found is Theo Browne's review on the T3 (t3.gg) channel, published the day after launch. It's useful partly because it doesn't simply accept Anthropic's framing.

Theo's central argument is that Sonnet 5.5 is a poor model to select as your main model and a great one to delegate to. In short, Sonnet is the model you hand work to, not the one you talk to.

The findings that stood out to me:

• Theo's own benchmark: a deep pull-request audit of a large real-world codebase. Sonnet 5.5 cost about half as much as Opus, scored slightly better on the automated judging, and finished in about five minutes. Opus took roughly twice as long and GPT-6 Astra roughly three times as long.
• Everyday coding cost. For like-for-like coding work, Theo found Sonnet often ends up costing as much as Opus, or more, because of cache reads and heavy token use. That isn't what I've seen day to day, but it's a fair warning for long agent loops, and it fits the cache example above.
• Max effort. Token usage jumps dramatically from xhigh to max for very little gain. Theo's advice is to pretend max doesn't exist.
• Cache pricing. Theo made the same criticism I did.
• Design. Theo found it worse than Opus and Fable 5.1, though ahead of OpenAI's and xAI's models.

Where I land compared with Theo: I agree on cache pricing, on max effort, and on Sonnet's value as a sub-agent. I'm more positive about picking it directly as a general-purpose model. Theo's review focuses on coding workflows, which is exactly where Opus's lead is biggest. Theo is also much harsher on GPT-6 Sol than I am.

Sonnet 5.5 vs GPT-6 Sol: same price, opposite approaches

OpenAI released GPT-6 Sol on September 22 as its mid-tier "workhorse" model, below the flagship GPT-6 Astra. Its API price is $2 input, $0.20 cached input, $10 output, identical to Sonnet 5.5 at standard context length.

That's why I find this matchup so interesting. Price is off the table, so the question becomes how each model spends your money. OpenAI also took the opposite pricing approach to Anthropic: Sol's price is half of what GPT-5.6 Sol cost ($4/$20).

	Claude Sonnet 5.5	GPT-6 Sol
Input / cached / output (per MTok)	$2 / $0.20 / $10	$2 / $0.20 / $10
Long-context pricing	Full 1M window at standard rates	Separate higher rate: $4 / $0.40 / $15
AA Intelligence Index (max effort)	56	48
AA cost per task (max effort)	$7.60	~$1.05
Output tokens per task (max)	~193K	~31K
Terminal-Bench 4.0 (AA)	63.6%	43%
FrontierCode 1.1, max (Anthropic-reported)	46.2%	49.3%
GDPval-AA v2.1 (Anthropic-reported)	1844	1487

Sol is frugal. Sonnet 5.5 spends more to reach a higher ceiling:

• Sonnet 5.5
• GPT-6 Sol

Intelligence Index

30405060

Sonnet 5.5GPT-6 Sol

$0.10$0.30$1$3$10

Cost per task

Source: Artificial Analysis, as of September 29, 2026. The cost axis is logarithmic.

Show the data

Model	Effort	Cost per task	Index score
Sonnet 5.5	Low	$0.41	36
Sonnet 5.5	Medium	$0.59	41
Sonnet 5.5	High	$1.08	47
Sonnet 5.5	Xhigh	$2.74	52
Sonnet 5.5	Max	$7.60	56
GPT-6 Sol	Low	$0.13	34
GPT-6 Sol	Medium	$0.25	40
GPT-6 Sol	High	$0.38	43
GPT-6 Sol	Xhigh	$0.52	44
GPT-6 Sol	Max	$1.05	48

Sonnet 5.5

~193K

GPT-6 Sol

~31K

Source: Artificial Analysis's launch analyses of Sonnet 5.5 and GPT-6 Sol. Approximate figures.

Show the data

Model	Output tokens per task
Sonnet 5.5	~193K
GPT-6 Sol	~31K

For the cheapest acceptable answer at scale, Sol is a serious option. For a model that can go further when I let it, and especially for knowledge work, where Sonnet's lead is large, I'd pick Sonnet 5.5.

How I'd actually use Sonnet 5.5

• Default for everyday work instead of Opus, at low or medium effort. It's far cheaper and pretty good.
• As a sub-agent for codebase exploration, research, audits and scoped fixes, with Opus 5.5 or Fable 5.1 orchestrating.
• Skip max effort. Xhigh is the highest I'd go.
• Hard coding and frontend work: Opus 5.5 or Fable 5.1.
• Cache-heavy agent loops: measure Sonnet against Opus on your own workload. The gap is smaller than the list prices suggest.
• Coding agents at low effort: add Anthropic's verification paragraph to the system prompt.

The verdict

Sonnet 5.5 is the most cost-effective Sonnet Anthropic has shipped. That isn't because the price went down. It didn't. It's because the model wastes much less. That mostly fixes the junior engineer problem I wrote about with Sonnet 5.

The best part, for me, is how it compares with Opus 5.5: very cheap, and still pretty good. For most everyday work, that's the trade I want.

Three things stop it from being an automatic choice. Anthropic left Sonnet's cache pricing alone while cutting it everywhere else. When you need Opus-level results, Opus 5.5 at a lower effort level can be the better deal. And for coding, Sonnet 5.5 is good, but not the best.

It's a strong release, just not one that's right for every job.

---

A note on sources: benchmark numbers labelled "Anthropic-reported" come from Anthropic's launch post. Index scores, cost per task, speed and token counts come from Artificial Analysis's independent testing. Prices come from Anthropic and OpenAI. Theo's findings are from the T3 review. Everything written as "I think" is my own opinion.