Claude Sonnet 5.5 Deep Dive: Anthropic's Hidden Weapon Against OpenAI

Anthropic's momentum has become impossible to ignore. From Fable 5.1 becoming many developers' favorite coding model, to Opus 5.5 taking over entire workflows, now comes Sonnet 5.5 — a release with unmistakably clear strategic intent: target OpenAI wherever possible.

Sonnet Returns: An Underestimated Release

Honestly, Sonnet 5.5 was a model I had planned to skip entirely and not bother covering. The reason was simple: Opus 5.5's price-to-value ratio is already stunning enough that I hadn't chosen Fable for any task in over a week. And the previous Sonnet 5 was one of my least favorite model releases in recent memory — it felt more like a collection of robots trying to mechanically execute specific scenarios than an assistant that genuinely understood the task.

But I was wrong this time. Sonnet 5.5 is a genuinely impressive model — it just shines in ways you might not expect.

Anthropic officially positions it as a meaningful upgrade over Sonnet 5: 30% faster, with costs reduced by up to 30% for most workloads. It's framed as a lightweight complement to Opus 5.5 — Opus handles complex work requiring careful judgment, while Sonnet 5.5 excels at well-scoped, everyday tasks like fixing bugs, generating documentation, slides, and spreadsheets. Haiku 5.5 has also been previewed to join the family in the coming weeks, targeting high-concurrency, cost-sensitive use cases.

Benchmarks: The Truth Behind the Numbers

Sonnet 5.5 achieved a record-breaking 70.6% on Terminal Bench, compared to just 10.3% for its predecessor — a sevenfold leap. A Sonnet-tier model holding the all-time record on Terminal Bench is simultaneously surprising and cause for skepticism about the benchmark itself.

It scores slightly below Opus 5.5 on GDPVal, performs strongly on long-horizon tasks and image understanding, and became the first Sonnet model to complete Pokémon Red using only screenshots. It feels like Anthropic has achieved some internal breakthrough at the reinforcement learning level — the smaller models no longer "clumsily execute" the way they used to, and now feel more like slightly less intelligent, faster versions of Fable.

But the real problem shows up in the Artificial Analysis intelligence index: at every tier, Sonnet 5.5 is both more expensive and less capable than Opus 5.5. On real-world tasks, Sonnet 5.5's cost runs almost neck-and-neck with Fable 5.1 — the most expensive tier they've run. This should have been a death sentence for the model.

The Pricing Puzzle: Cache Reads Are the Key

Sonnet 5.5 is priced identically to Sonnet 5: $2 per million input tokens, $10 per million output tokens, and $0.20 for cache reads. The problem lies squarely in those cache reads.

For today's everyday agentic coding work, cache reads and cache writes often represent the bulk of costs. Fable 5.1 slashed cache read costs by 90%, Opus reduced them by around 60%, but Sonnet 5.5 receives no such discount.

Looking at the pricing structure: from Sonnet to Opus, input/output costs double; from Opus to Fable, they double again. But cache read costs barely change between Sonnet and Opus, and only rise about 25% going to Fable. This means as you move toward lower-end models, cache reads represent an increasingly large share of total costs — under 5% for Fable, approaching 20% for Opus, and potentially exceeding 50% for Sonnet 5.5.

The result: when running equivalent real coding tasks, Sonnet's actual cost often matches or exceeds Opus. Regular input tokens are nearly unused in agentic work (most content is read from cache), and output tokens represent only a small fraction.

Prompt Caching is an important mechanism in modern LLM APIs. In agentic workflows, system prompts, codebase context, tool definitions, and similar content are repeatedly passed to the model across multiple turns. Charging full input token rates each time would make costs prohibitive. Caching allows model providers to retain this repeated content server-side for a period, charging only a fraction of the normal input price — the "cache read fee" — when subsequent requests hit the cache. Using Anthropic's pricing structure as an example, the price difference between regular input tokens and cached read tokens can be 5 to 10x, meaning cache hit rates directly determine your actual bill on long-context or multi-step agent tasks. Fable (Claude 3's Haiku tier) offered deep discounts on cache reads, while Sonnet 5.5 fails to extend that benefit, dramatically eroding its real-world cost advantage in cache-heavy scenarios. This is the essential background for understanding this article's core pricing argument.

Stay Away From Max Mode: A Critical Warning

If there's one thing that must be made absolutely clear: don't use Max mode.

Reasoning levels aren't really "levels" — they're "budgets." Setting low, medium, high, or x-high allows the model to use up to a certain ceiling of reasoning tokens, but doesn't necessarily increase actual usage. On simple tasks, the token difference between low and x-high might be only 5–8%.

The problem with Max is that it doesn't raise the "ceiling" for reasoning tokens — it raises the "floor." It tells the model: "don't consider the task done until you've reached a certain level of reasoning." In benchmarks I've tested, token usage skyrocketed by 1,500% — a full 15x — going from x-high to Max. Worse, forcing the model to overthink frequently hurts performance, causing it to second-guess itself and produce wrong answers.

In real testing, Sonnet 5.5 on Max cost $7.60 to run one benchmark — more than double the equivalent Astra run. Switching to High or Medium dropped the price to $1.08 and $0.59 respectively. On the Frontier Code benchmark, x-high actually scored higher than Max and outperformed GPT-6 Sol, while Max dropped below Sol. Choosing to lead a blog post with a chart showing "Max beats Opus" is a genuinely strange editorial choice.

Reasoning Models are large language models that generate an internal "thinking process" (thinking tokens) before delivering a final answer, with representative products including OpenAI's o-series and Anthropic's Claude extended thinking mode. These thinking tokens are typically billed as well, but their value varies significantly by task complexity. The reasoning budget is a parameter that controls thinking depth: with a low budget, the model only expands into reasoning when necessary; with a high budget, it can use more tokens to deliberate. The critical issue the article identifies is that "Max" mode doesn't simply allow more reasoning — it mandates that the model reach at least a certain level of reasoning, effectively raising the floor rather than the ceiling. This is especially harmful for simple tasks, where the model is forced into excessive analysis that introduces noise and self-doubt, degrading accuracy while causing costs to spike dramatically.

Token Inefficiency and the Speed Illusion

Sonnet 5.5 is not a token-efficient model. On Cursor Bench, it consumed 271,920 tokens per task — more than Opus's 218k, nearly double Gemini 3 Flash, and more than five times GPT-6 Sol and Astra.

On speed: according to OpenRouter, calling Sonnet 5.5 through Anthropic runs around 94 tokens/sec, while Opus 5.5 runs around 70. In personal testing on official subscriptions, Sonnet was around 150 tps and Opus around 100 tps. It's faster — but because it consumes so many more tokens, actual wall-clock completion time ends up longer. In a "fish slop" demo, Sonnet took 43 minutes versus Opus's 36; the pure generation time gap was even larger, 39 minutes versus 27.

Front-end design is another weak spot. In the Witch AI design showcase, Sonnet's output had scrolling glitches, background lines degrading readability, and ugly card designs — worse than Opus, and considerably worse than Fable. Fable 5.1 remains the best overall frontend design model.

The Real Value: As an Orchestrated Tool

At this point you might be wondering: if Sonnet 5.5's frontend is weak, it consumes more tokens, it's not smarter than Opus, and it's not cheaper either — what exactly does the author like about it?

The answer: neither you nor I should be selecting Sonnet 5.5 directly, but as a tool that other models can call, its value is enormous. It shouldn't be invoked directly by users — it should serve as one of many components that Opus or Fable orchestrates when breaking down complex work.

I validated this with a "deep audit" benchmark: asking each model to perform deep analysis of a massive PR with hundreds of thousands of lines of code and propose actionable strategies. This wasn't a traditional coding test — it was a task weighted toward analysis and architectural decision-making. Sonnet's performance was surprising: cost roughly half of Opus, score slightly higher than Opus, and the best cost-per-score ratio I've seen on this benchmark. More importantly, timing: it finished in about 5 minutes, while Opus took nearly double, and Astra nearly triple.

In other words, when Opus or Fable receives a large task and needs to analyze a codebase before acting, they can now call Sonnet to handle that research and be satisfied with the results. If you correctly configure Opus to call Sonnet as a sub-agent at the right moments, the net effect is that Opus feels faster and completes real work at slightly lower cost.

Multi-Agent Orchestration is an architectural pattern in which complex tasks are decomposed and completed collaboratively by multiple AI models. In this framework, an "orchestrator" typically handles task planning and delegation, while multiple "sub-agents" execute specific atomic steps. The orchestrator usually uses the most capable flagship model (such as Opus), while sub-agents can use faster, cheaper models for specific subtasks like code search, documentation generation, or format conversion. The advantage of this architecture is that overall output quality approaches that of using the flagship model end-to-end, but cost and latency can be dramatically reduced. Sonnet 5.5's demonstrated cost-effectiveness on codebase analysis tasks makes it an ideal sub-agent candidate in these architectures — fast enough, accurate enough, and at roughly half the cost of Opus for analytical tasks, enabling the overall orchestration system to reduce total spend while maintaining quality.

OpenAI Should Be Worried

I'll be direct: I won't be using Sonnet 5.5 heavily in my daily work, but it's an excellent addition to this new model family. Its ability to validate assumptions in real codebases, dig deep into specific behaviors, and its potential for office document tasks all represent substantial value.

What should genuinely worry OpenAI is the broader picture: Anthropic has taken the lead across all of its strongest dimensions — not the smartest model, not the most efficient model, not the cheapest model, and not the best model for orchestrating other models. I'll say plainly that $200 of Codex subscription delivers far less real coding output than $200 of Claude subscription.

GPT-6 Sol, in my view, arrived essentially DOA — there's not much I want to say about it. With OpenAI Dev Day approaching, the company is bound to strike back. But at the current pace, the competition is only going to accelerate.