Anthropic has just released Claude Sonnet 5. Sonnet. Had to say it twice.

It is the middle child of the Claude family, and the one most people will actually use. It is quick, capable, cheap to run, and free to use for all users without any subscription.

In this article, we go over the latest iteration of the Claude’s Sonnet family with Sonnet 5. We put it to test to see whether its agentic claims had any truth to them or not. And how a regular usr of Claude gets impacted with this free upgrade.

Sonnet 5 is now the default model for all users. If you use Claude without paying, this is the model you are talking to. Opus stays behind a paid plan, so for most people, Sonnet 5 is simply what Claude is. In short, the following improvements have been made:

Claude comes in three sizes. Haiku is the fast one, Opus is the heavyweight, and Sonnet sits comfortably in the middle.

Here is the part worth noticing: Sonnet just moved to version 5. Haiku is still 4.5 and Opus is 4.8, so Sonnet 5 is the most recently rebuilt model in the whole lineup.

Running Sonnet 5 is far cheaper than running Opus. Right now it is cheaper still, thanks to a launch price that lasts until the end of August. For anyone running it a lot, that gap adds up fast.

Sonnet 5 does not just chat. It can take on a task and carry it through. It makes a plan, uses tools like a web browser and your files, does the work, and then checks its own answer before handing it back.

The big change from the last version is that it finishes the job. Earlier models often stopped halfway through longer tasks. Sonnet 5 tends to see them through, and it double checks itself without being told to.

It is also a little safer to hand things to. It is better at turning down dodgy requests, harder to trick, and makes things up less often than the Sonnet before it (something that a lot of people may not like).

Create a temporary Python project called agentic_sonnet_test. Inside it, create these files exactly:

cart.py

class Cart:

def __init__(self):

self.items = []

def add(self, name, price, quantity=1):

self.items.append({"name": name, "price": price, "quantity": quantity})

def subtotal(self):

return sum(item["price"] for item in self.items)

def discount(self):

total = self.subtotal()

if total > 100:

return total * 0.1

return 0

def total(self):

return self.subtotal() - self.discount()

def receipt(self):

lines = []

for item in self.items:

lines.append(f'{item["name"]}: ${item["price"]}')

lines.append(f"Total: ${self.total()}")

return "\n".join(lines)

test_cart.py

from cart import Cart

def test_subtotal_uses_quantity():

cart = Cart()

cart.add("Book", 10, quantity=3)

cart.add("Pen", 2, quantity=5)

assert cart.subtotal() == 40

def test_discount_applies_at_100_or_more():

cart = Cart()

cart.add("Keyboard", 100, quantity=1)

assert cart.discount() == 10

def test_total_after_discount():

cart = Cart()

cart.add("Monitor", 150, quantity=2)

assert cart.total() == 270

def test_receipt_shows_line_totals_and_quantity():

cart = Cart()

cart.add("Book", 10, quantity=3)

receipt = cart.receipt()

assert "Book x3: $30" in receipt

assert "Subtotal: $30" in receipt

assert "Discount: $0" in receipt

assert "Total: $30" in receipt

Do the following:

1. Run the tests.

2. Inspect the failure output.

3. Fix the implementation in cart.py.

4. Re-run the tests.

5. Keep debugging until all tests pass.

6. Do not edit the tests.

7. At the end, show:

• the final cart.py
• the exact test command you ran
• the final test result
• a short explanation of what was broken and how you fixed it

Response:

Verdict: Sonnet 5 ran the tests before touching any code, diagnosed three separate bugs instead of patching blindly, and never edited the test file to force a pass. It then reran everything to confirm the fix actually held. Careful, disciplined debugging that closes the loop properly rather than just claiming success.

Prompt:

I’m trying to choose the easiest online environment for running small Python experiments with a terminal. Compare Replit, GitHub Codespaces, and Google Colab using current official docs or help pages. For each one, check whether it supports:

• creating files

• running shell or terminal commands

• installing packages

• saving or sharing the workspace

• lowest-friction setup for a beginner

Please don’t rely on memory. Verify from sources.

At the end, give me:

• a comparison table

• your recommendation

• links to the pages you checked

• anything you’re uncertain about

Response:

Verdict: Sonnet 5 skipped relying on memory and checked real documentation for each platform, comparing all three against the same criteria so nothing felt lopsided. It ended with an honest recommendation while flagging where its own judgment was subjective. Thorough, well sourced, and refreshingly upfront about its limits.

Note: I use the Pro subscription. On Sonnet 5 with Medium thinking level, about 3-5% of usage limit was used per agentic task. This is super efficient.

Sonnet 5 is not trying to be the smartest model on earth. Opus still owns the hardest problems. It is trying to be the one you reach for every day.

So not only have the regular problem solving capabilities of the Sonnet models improved, but also the usage exhausted for doing the same is a lot less (due to using a Sonnet model over an Opus one). This leads to longer/denser conversations without the dread of the usage limit reaching out.

Overall, the end users that might not have a subscription just got an upgrade over their default mode. As to the ones with a subscription, I don’t think Sonnet 5 would be taking over your workloads from Opus 4.8. When it comes to using them via API, it’s a completely different conversation altogether.

A. Claude Sonnet 5 is Anthropic’s June 30, 2026 model built for agentic tasks, coding, tool use, and everyday professional work.

A. Yes. It is the default model for Free and Pro users, while Opus remains on paid plans.

A. API pricing starts at $2 input and $10 output per 1M tokens until Aug 31, 2026.