Claude Sonnet 5 Released: Anthropic Has Driven Down Agent Pricing

Today (June 30), Anthropic released Claude Sonnet 5. The pitch this time is straightforward—not pushing the model to the absolute capability ceiling, but cutting the price of a model that can actually run agents.

If the Fable 5 launch three weeks ago was Anthropic’s play for “maximum capability,” then Sonnet 5 is its play for “everyday production environments.” The former costs $50 per million output tokens, while the latter aggressively pushes that curve downward. For most teams embedding Claude into agent pipelines, Sonnet 5 is the variable that actually impacts the monthly bill.

What actually changed this time

First, the hard specs. Sonnet 5 inherits the standard capabilities of Anthropic’s current-generation models:

• 200K context window (enterprise version unlocks up to 1M, matching Fable 5)
• 64K maximum output
• Native tool calling and parallel tool use, with Anthropic claiming it can launch more tool calls in a single turn without “forgetting what it’s doing”
• Improved computer use, with noticeable gains over Sonnet 4.6 on OSWorld
• ASL-3 safety level, stricter than the previous generation

But none of those are the real focus of this release. The focus is pricing. Sonnet 5’s API pricing is $3 per million input tokens and $15 per million output tokens—the same as Sonnet 4.6, but with capabilities approaching Opus 4.8. In other words, Anthropic has once again pushed the price-performance ratio further within the same pricing tier.

This is Anthropic’s usual rhythm: Opus/Fable carries the capability ceiling, while Sonnet brings the previous generation’s capabilities down to half or even a third of the price. Sonnet 3.5 did the same thing back then, effectively making Opus 3 irrelevant for most users. Sonnet 5 will likely follow the same script with Opus 4.8.

Why the focus on “low-cost agents”

This needs to be viewed in the context of the past two years.

Over the last year, “agents” have moved from demos into production environments. Anyone who has run one for more than a few days knows a simple truth: the main cost of agents doesn’t come from expensive models—it comes from models talking too much. A moderately complex task can easily rack up hundreds of thousands of tokens after a few planning rounds, several tool calls, document reads, and a reflection pass. Running something like Opus end-to-end causes costs to grow at a very inelegant rate.

Anthropic clearly knows this too. Two months ago, they launched the advisor tool, where cheaper models act as the main executors while Opus becomes a pay-per-use “advisor” only called at key decision points. That was essentially an admission of one thing: top-tier models are not well suited for the execution layer of agents.

Sonnet 5 continues this strategy, but pushes it further. Its positioning is very clear: allow most agent workflows to run on a single model without requiring complex multi-model orchestration. Once you combine sufficient capability, sustainable pricing, and stable tool calling, most teams no longer need to agonize over whether to use planner-solver or advisor architectures.

That’s why Anthropic repeatedly emphasizes “agentic capabilities” and “tool use reliability” throughout the release materials—they want Sonnet 5 to become the default choice for developers.

Tool calling: this time it’s actually stable

Sonnet 5 introduces several notable improvements in tool use.

The first is the reliability of parallel tool calling. Sonnet 4.6 already supported multiple tool calls in a single turn, but in practice it often “missed one” or ignored results after calling a tool. Sonnet 5 significantly reduces these issues in Anthropic’s internal agentic evaluations. According to official data, completion rates for multi-step tool tasks improved by roughly 18 percentage points over 4.6.

The second is state retention during long-running tasks. This is more subtle. After the 15th or 20th tool call, does the model still remember the original goal? Does it get derailed by an intermediate tool error? Sonnet 5 clearly shows engineering optimizations here. From the early tests I’ve seen, during complex tasks lasting over half an hour, the probability of “forgetting what it was doing midway through” is noticeably lower than in the previous generation.

The third is the detailed experience of computer use. Stability has clearly improved in screenshot understanding, coordinate localization, and UI element recognition. This is a practical upgrade for teams building browser agents or desktop automation systems.

How it compares to GPT-5.5 and Gemini Pro

Cross-model comparisons are unavoidable.

In terms of raw capability, Sonnet 5 sits roughly between GPT-5.5 and Gemini 2.5 Pro. It performs slightly better in coding and agentic tasks, but somewhat weaker in pure mathematical reasoning. This aligns with Anthropic’s longstanding direction: they don’t chase benchmark competition scores like AIME, but instead focus obsessively on reliability in real engineering tasks.

In terms of pricing, Sonnet 5 is the cheapest of the three. GPT-5.5 standard pricing is around $5/$25 per million input/output tokens, Gemini 2.5 Pro sits near $4/$20, while Sonnet 5 comes in at $3/$15—a noticeable advantage. If prompt caching is factored in, the effective cost of long-running agent tasks drops even further.

In terms of ecosystem, OpenAI still leads, with the most complete SDKs, community support, and third-party tooling. But Claude’s reputation in coding and tool use has overtaken the GPT series over the past two years. Especially with the growth of the Claude Code product line, “use Claude for coding” has practically become the default consensus among developers.

For long context, Gemini still has the advantage with native million-token support and multimodality. But realistically, there are not many agent scenarios that truly require stuffing in a million tokens. More often, the workload involves dense tool interaction within the 100K–200K range—which is exactly where Sonnet 5 performs best.

A simple usage example

Sonnet 5 is fully compatible with the OpenAI format. Through OpenAI Hub, you can call it directly using a single API key, with direct domestic access in China and no proxy hassle:

from openai import OpenAI

client = OpenAI(
    base_url=\"https://api.openai-hub.com/v1\",
    api_key=\"your-key\"
)

response = client.chat.completions.create(
    model=\"claude-sonnet-5\",
    messages=[
        {\"role\": \"system\", \"content\": \"You are a helpful coding agent.\"},
        {\"role\": \"user\", \"content\": \"Help me refactor this code and write unit tests\"}
    ],
    tools=[
        {
            \"type\": \"function\",
            \"function\": {
                \"name\": \"run_tests\",
                \"description\": \"Run test cases\",
                \"parameters\": {
                    \"type\": \"object\",
                    \"properties\": {
                        \"file\": {\"type\": \"string\"}
                    }
                }
            }
        }
    ],
    tool_choice=\"auto\"
)

print(response.choices[0].message)

If you were previously using Sonnet 4.6, migration is basically seamless: API fields are unchanged and the tool-calling protocol remains backward compatible. One thing worth noting, however, is that Sonnet 5 is no longer particularly sensitive to manually written “step-by-step thinking” prompts. Forcing chain-of-thought prompting can actually hurt performance. Anthropic already emphasized this with Fable 5, and Sonnet 5 follows the same philosophy: the model internally handles the reasoning process, leaving less room for external prompt engineering.

A few details worth paying attention to

Prompt Caching enabled by default: Prompts longer than 1024 tokens are automatically cached, and cached portions are billed at 10% of the normal rate. For agents with system prompts running several thousand tokens, this alone can save a significant amount of money.

Batch API at half price: Asynchronous tasks receive a 50% discount. Teams running large-scale data processing or offline evaluations should make heavy use of this.

Extended Thinking mode: Like Fable 5, Sonnet 5 also includes optional extended thinking. But Anthropic subtly suggests in the documentation to avoid enabling it unless necessary—which basically means the model already knows how much reasoning most tasks require, and forcing extended thinking only increases token costs.

No major changes to vision: Image understanding remains roughly on par with 4.6, without native video support like Gemini. Anthropic has consistently been relatively conservative on the multimodal front.

What this release means

On a broader level, Sonnet 5 confirms a trend: frontier AI companies are beginning to treat “cost-effective models” as flagship products rather than cheap substitutes for flagship models.

GPT-5.5 mini, Gemini 2.5 Flash, and Sonnet 5 are all converging in the same direction: sufficient capability, low enough pricing, and stable enough tool use. The reason is simple—companies running agents in production cannot sustainably afford top-tier model bills forever. The market demand is obvious: whoever pushes the “good enough and cheap enough” curve furthest will capture most of the growth.

On a more practical level, Sonnet 5 will likely become the default choice for developers over the next six months. If you’re choosing a model for agent workloads right now, the sensible setup is: use Sonnet 5 as the primary executor, and Fable 5 as the advisor for critical decision points. This is the most complete version of Anthropic’s system architecture so far.

OpenAI Hub has already integrated Claude Sonnet 5 immediately after launch. As before, a single API key works end-to-end, fully compatible with the OpenAI format, without requiring separate account registration for new models. If you want to test it while the release is still fresh, you can start using it today.

References

• Claude Fable 5 Is Here: This Isn’t Just a Minor Opus Upgrade - Zhihu — An in-depth analysis of Anthropic’s previous-generation flagship model Fable 5, providing important context for understanding Sonnet 5’s positioning