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.

The People’s Model

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:

• Task Follow Through: completes complex multi-step tasks fully instead of stopping early.
• Self Verification: checks and confirms its own work without being prompted to.
• Agentic Tool Use: plans, uses tools, executes, and reviews its own output.
• Lower Cost: cheaper per token than Opus, with a discounted launch price.
• Improved Reliability: declines bad requests better and hallucinates less often.

Meet the Family

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.

It Costs Less

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.

Agentic Focus: What It Actually Does

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).

Hands-On: Testing the Agentic Capabilities

Test 1: Agentic Capabilities

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.

Test 2: Tool Use + Planning + Self Correction

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.

Conclusion

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.

Frequently Asked Questions