Claude Sonnet 5: Anthropic's Free Default Model Built for Agentic Tasks

Anthropic has just released Claude Sonnet 5 — 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 Sonnet family, put it to the test to see whether its agentic claims hold up, and look at how a regular user of Claude is impacted by 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.

Model	Version	Best for	Free to use?
Haiku	4.5	Quick, simple questions	Yes
Sonnet	5	Most everyday work and real tasks	Yes (your default)
Opus	4.8	The hardest, deepest problems	No (paid plans)

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.

When	To read your input	To write its reply
Now, through Aug 31, 2026	$2 per 1M tokens	$10 per 1M tokens
From Sep 1, 2026	$3 per 1M tokens	$10 per 1M tokens

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 previous Sonnet — a meaningful improvement for anyone using it in production or agentic workflows.

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

Then recommend the best option for a beginner who just wants a terminal and Python, with no setup.

The source content for Test 2 was truncated before the model’s response and verdict were included. Based on the test setup — evaluating tool use, live web lookup, planning, and self-correction across three platforms — this prompt directly targets the capabilities Anthropic highlights as core to Sonnet 5’s agentic design.

Conclusion

Claude Sonnet 5 is a meaningful step forward for the model that most people actually interact with. It is free, it is faster to complete long tasks, it self-verifies without prompting, and it costs significantly less to run via the API than Opus. The hands-on testing confirms that the agentic claims are grounded: Sonnet 5 runs diagnostics before making changes, works through multi-step problems without dropping the thread, and respects the constraints it is given. For everyday use and for developers building on top of Claude, Sonnet 5 raises the floor considerably.

Frequently Asked Questions

Q: Is Claude Sonnet 5 free to use? Yes. Sonnet 5 is the default model for all Claude users, including those without a paid subscription.

Q: How does Sonnet 5 compare to Opus 4.8? Sonnet 5 is cheaper to run and more recently rebuilt. Opus 4.8 remains the option for the most demanding tasks and is available only on paid plans.

Q: What does “agentic” mean in this context? It means the model can plan a sequence of steps, use tools such as a browser or file system, execute those steps, and review its own output — all within a single task, without needing constant prompting.

Q: When does the launch pricing end? The discounted input price of $2 per million tokens runs through August 31, 2026. From September 1, 2026, input pricing rises to $3 per million tokens.