Claude Sonnet 5 Review: A Week With Anthropic's New Default

TL;DR

Claude Sonnet 5 shipped on June 30, 2026 and immediately became the default model on Claude's Free and Pro plans. Anthropic's published numbers put it at 63.2% on SWE-bench Pro, a few points behind Opus 4.8's 69.2% but well ahead of Sonnet 4.6's 58.1%. On Terminal-Bench 2.1 it actually beats Opus 4.8 (80.4% vs 74.6%). Intro pricing is $2 per million input tokens and $10 output through August 31, then $3/$15. One detail is easy to miss: it ships with a new tokenizer that uses 1.0–1.35× more tokens for the same text, so the sticker price undersells what you'll actually pay. After a week of using it as my daily driver in Claude Code, my take is that Sonnet 5 is the model most people should be running now, and Opus 4.8 has shrunk to a specialist tool you reach for on the genuinely hard problems.

What Claude Sonnet 5 Actually Is

Anthropic ships models in three sizes: Haiku for cheap and fast, Sonnet for the middle, Opus for the frontier. Sonnet has always been the workhorse, the one that runs when you don't think about which model you're using. Sonnet 5 is the fifth generation of that workhorse, and the pitch is that the middle tier has crept close enough to the top tier that the top tier stops being the obvious choice.

It landed as the default for Free and Pro on claude.ai the day it launched, with access for Max, Team, and Enterprise, plus the API id claude-sonnet-5 on the Claude Platform and inside Claude Code. That default placement counts for more than the benchmarks. Most Claude traffic never picks a model on purpose. Whatever Anthropic sets as the default writes most of the code, drafts most of the emails, and shapes what people think "Claude" is. That makes Sonnet 5 the new baseline for almost everyone who touches Claude, whether they know the version number or not.

I flipped my Claude Code default to it on launch morning and left it there for a week, running it against a Go service with a messy migration path, a Next.js dashboard, and a pile of one-off scripts. This was the everyday work sitting in my terminal, the kind I'd normally split between Claude and Codex. What stuck with me is that it finishes things. Multi-step tasks that used to stall halfway and wait for me to nudge them now run to completion on their own, and that single behavioral change is worth more than any single-digit benchmark bump.

The Benchmark Breakdown

Here are the numbers Anthropic and early testers published, lined up against the two models Sonnet 5 is really being measured against: its own predecessor and the flagship one rung up.

Benchmark	Sonnet 5	Sonnet 4.6	Opus 4.8
SWE-bench Pro (agentic coding)	63.2%	58.1%	69.2%
Terminal-Bench 2.1	80.4%	—	74.6%
OSWorld-Verified (computer use)	81.2%	78.5%	83.4%
BrowseComp (agentic search)	84.7%	—	—
GDPval-AA v2 (knowledge work, Elo)	1,618	—	1,615
FrontierCode	38.8%	15.1%	—

Two rows stand out. On SWE-bench Pro, the 5.1-point jump from Sonnet 4.6 to Sonnet 5 (58.1 to 63.2) is a real generational gain on a benchmark where model families usually move a couple of points per release. FrontierCode more than doubled in reported results, from 15.1% to 38.8%. Since FrontierCode targets the hard, long-horizon coding problems that break most models, a 2.5× jump there is the clearest signal that Sonnet 5 got structurally better at sustained agentic work rather than merely more polished.

The Terminal-Bench result is the one that made me raise an eyebrow. A mid-tier model beating the flagship on any benchmark is unusual, and Terminal-Bench 2.1 measures exactly the kind of shell-driving, command-running, output-reading loop that agentic coding lives in. Sonnet 5's 80.4% against Opus 4.8's 74.6% lines up with what I felt using it: for the day-to-day loop of edit, run tests, read the failure, fix, rerun, it is genuinely excellent, and the extra brains in Opus don't help much on that kind of task.

Where Opus still wins is SWE-bench Pro and OSWorld, both by a handful of points. Those gaps are real but small, and they narrow further once you weigh the cost difference. The GDPval knowledge-work Elo is essentially a tie (1,618 vs 1,615), which tells you the reasoning and writing quality of the two models is now hard to tell apart on ordinary tasks.

A Week Of Real Use

Benchmarks tell you a model's ceiling. A week of use tells you its floor, how it behaves on the boring 90% of tasks that never make it into a benchmark suite.

The best thing about Sonnet 5 is the self-verification loop. On my Go service, I asked it to migrate a set of handlers from a hand-rolled router to chi and update the tests. Sonnet 4.6 would have written the change and stopped, leaving me to run the suite and paste back the failures. Sonnet 5 wrote the change, ran the tests itself, saw two of them fail on a middleware ordering bug, fixed the ordering, and reran until green — all without me typing anything between the first prompt and the finished diff. It did this consistently over the week, not once as a lucky demo. Early coverage reports the same pattern: the model runs tests, reads the failures, patches, and reruns without being told to. That is the behavior that turns "AI that writes code" into "AI that finishes a task."

The second thing I noticed is that it's honest about uncertainty more often. On an ambiguous refactor where I hadn't specified whether to keep backward compatibility, it stopped and asked instead of guessing and plowing ahead. That's a small thing that saves a lot of wasted diffs.

It still has clear failure modes. On a gnarly Next.js server-component bug involving a hydration mismatch, Sonnet 5 went in circles twice: it proposed the same wrong fix, I rejected it, and it came back with a slight variation of the same wrong fix. I switched that one task to Opus 4.8 and it found the actual cause (a Date being rendered without a stable server/client format) in one pass. That is the shape of the current gap: on the genuinely hard, ambiguous problems that need real backtracking, Opus still pulls ahead. On everything else, you won't notice a difference.

The Tokenizer Tax

The pricing page leaves out one detail. Sonnet 5 ships with an updated tokenizer, and Anthropic's own announcement says it produces roughly 1.0 to 1.35× more tokens for the same input text than Sonnet 4.6 did. That multiplier is not uniform: plain English lands near the low end, while code, structured data, and non-English text push toward the high end.

What that means in practice: the $2/$10 intro price is genuinely cheap, but your token counts go up, so the effective cost per request rises more than the sticker drop suggests. If you're comparing Sonnet 5's $3/$15 standard price against Sonnet 4.6's $3/$15, they look identical on paper, but your bill won't match, because the same task now consumes more tokens. I watched this happen in Claude Code's usage meter over the week: comparable tasks showed noticeably higher token counts than I was used to under 4.6.

This doesn't make Sonnet 5 expensive. It's still dramatically cheaper than Opus 4.8. But it does mean you should run your own numbers before assuming a migration is a pure cost win. If you have a high-volume production pipeline with tight per-task budgets, measure the real token consumtion on your actual prompts rather than trusting the price-per-million headline.

Model	Input / 1M	Output / 1M	Notes
Sonnet 5 (intro, through Aug 31)	$2	$10	New tokenizer, +0–35% tokens
Sonnet 5 (standard, from Sep 1)	$3	$15	Same sticker as 4.6, higher token use
Sonnet 4.6	$3	$15	Older, cheaper-per-token tokenizer
Opus 4.8	$5	$25	Flagship; reach for the hard tasks

When To Use Sonnet 5 vs Opus 4.8

After a week, my routing rule is simple. Send everything to Sonnet 5 by default. Reach for Opus 4.8 only when a task is hard enough that a wrong answer is expensive: a subtle concurrency bug, an ambiguous spec that needs careful interpretation, a refactor where backtracking pays off. Keep Haiku 4.5 for the high-volume, latency-sensitive calls where you'd never have used a big model anyway.

That's a real shift from three months ago, when Opus was my default for anything that mattered and Sonnet was the "good enough, save money" option. Now the ordering has flipped: Sonnet 5 is the default that's good enough for almost everything, and Opus is the specialist you escalate to, with Fable 5 sitting above it for the longest autonomous runs. The GDPval tie and the Terminal-Bench win explain why. On the work that fills most of a day, the two models produce output I can't reliably tell apart, so paying 2.5× more for Opus stops making sense.

If you're weighing this against non-Anthropic options, the picture is more crowded than it was. GLM-5.2 undercuts everyone on price with open weights and lands close on coding benchmarks, and GPT-5.5 trades blows on general tasks. Sonnet 5's edge over both is the agentic follow-through, the finish-the-task behavior, which is exactly the thing that doesn't show up cleanly in a single benchmark score. For a broader field, our GPT vs Claude vs Gemini coding comparison still holds up on the general shape of the tradeoffs, even if the specific version numbers have moved.

How To Switch To Sonnet 5

If you're on claude.ai Free or Pro, you're already using it; it's the default. For everything else, you point at the model id.

Via the API with the Python SDK from the Anthropic console:

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY

message = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Refactor this Go HTTP handler to use chi router "
                       "and update the table-driven tests.",
        }
    ],
)
print(message.content[0].text)

In Claude Code, set it as the session default so every agent turn uses it:

# One-off for the current session
claude --model claude-sonnet-5

# Or make it sticky in your shell profile
export ANTHROPIC_MODEL="claude-sonnet-5"

If you drive Claude through a coding IDE, the same model id works. I run it as the default in Cursor for ordinary edits and only flip to Opus when a task fights back. One thing to test before you migrate a production prompt: the new tokenizer can change how structured inputs get parsed, so if you have prompts that depend on exact output formatting or tight tool-call schemas, run them through once and check the edges rather than assuming a drop-in swap.

Here's a quick way to sanity-check the token difference on your own text before and after switching, using the count-tokens endpoint:

import anthropic

client = anthropic.Anthropic()

resp = client.messages.count_tokens(
    model="claude-sonnet-5",
    messages=[{"role": "user", "content": open("prompt.txt").read()}],
)
print("Sonnet 5 input tokens:", resp.input_tokens)

Run that against a representative prompt, compare it to what the same text cost you under Sonnet 4.6, and you'll know your real multiplier instead of guessing at the 1.0–1.35× range.

Who Should Use It, Who Should Skip

Good fit:

• Anyone already on Claude for coding. Sonnet 5 is a straight upgrade over 4.6 in every category, and during the intro window it's cheaper too.
• Teams running agentic workflows (Claude Code, Cursor, custom harnesses) where the self-verification loop saves human turns.
• Cost-conscious builders who were paying for Opus out of habit. Most of that work drops to Sonnet 5 with no quality loss you'll notice.

Think twice:

• High-volume production pipelines with razor-thin margins. Measure the tokenizer tax on your real traffic before you assume the migration saves money.
• Anyone whose prompts depend on exact tokenization or output formatting. Test the edges first.
• Work that lives at the hard end of the difficulty curve: deep debugging, ambiguous specs, tasks that need backtracking. Keep Opus 4.8 in reach for those, and see our Claude Code Max vs Pro breakdown if you're deciding how much Anthropic compute to buy.

FAQ

How much does Claude Sonnet 5 cost?

Introductory API pricing is $2 per million input tokens and $10 per million output tokens through August 31, 2026, moving to $3/$15 after that. On claude.ai it's the default model on the Free and Pro plans at no extra cost. Factor in the new tokenizer, which uses 1.0–1.35× more tokens for the same text, when you estimate real spend.

Is Claude Sonnet 5 good for coding?

Yes — it's the strongest mid-tier coding model Anthropic has shipped. It scores 63.2% on SWE-bench Pro (up from Sonnet 4.6's 58.1%) and beats Opus 4.8 on Terminal-Bench 2.1. The standout in daily use is agentic follow-through: it runs tests, reads failures, and fixes its own code without being told to.

Claude Sonnet 5 vs Opus 4.8 — which should I use?

Use Sonnet 5 as your default for almost everything; it's close to Opus 4.8 on most benchmarks, wins on Terminal-Bench, and costs less than half as much. Reserve Opus 4.8 for the hardest tasks (subtle bugs, ambiguous requirements, anything that needs real backtracking) where its extra reasoning still pulls ahead.

What is Claude Sonnet 5's context window?

Sonnet 5 supports a 1 million token context window, matching the top of Anthropic's lineup. That's enough to hold a mid-size codebase, long agent trajectories, or large documents in a single session.

When was Claude Sonnet 5 released?

Anthropic released Claude Sonnet 5 on June 30, 2026, and made it the default model on the Free and Pro plans the same day.

Sources

• Introducing Claude Sonnet 5 (Anthropic): official announcement, pricing, availability, and the tokenizer change
• Claude models overview (Claude Platform Docs): model ids, context windows, and standard pricing
• Claude Sonnet 5 vs Sonnet 4.6 vs Opus 4.8 (MarkTechPost): benchmark table and cost-performance analysis
• Claude Sonnet 5 pricing: the hidden costs behind the "cost-neutral" launch (Finout): breakdown of the tokenizer's effect on real spend

Bottom Line

Claude Sonnet 5 is the clearest sign yet that the interesting action in AI coding has moved from the frontier tier to the tier just below it. It nearly matches Opus 4.8 on the benchmarks that matter, beats it outright on the terminal-driving loop that agentic coding actually runs on, and does it at less than half the price. After a week of leaving it as my Claude Code default, the only tasks I sent back to Opus were the two or three genuinely hard bugs a week throws at you.

The tokenizer tax is the one thing to watch. Sonnet 5 is cheaper than Opus and, during the intro window, cheaper than 4.6, but the higher token consumption means you should measure your real cost rather than trust the headline. Do that math, then switch. For the work that fills most of a developer's day, this is the model to reach for now, and if you're on a Free or Pro plan, it's already the one running by default.