🧭 Sonnet 5.5 Cache Reads Drop to $0.10/MTok — Agentic Pipeline Costs Fall ~20%

On October 7 — the same day Claude Haiku 5.5 launched — Anthropic quietly halved the cache-read price for Claude Sonnet 5.5, cutting it from $0.20 to $0.10 per million tokens. No blog post, no press release: the change appeared in the pricing table. For teams running high-throughput agentic workloads on Sonnet 5.5, the timing is important: cache reads typically account for 60–80% of total tokens consumed in agent pipelines (the same system prompt and tool schemas are prepended to nearly every request), so a 50% reduction in that line item translates to roughly a 20% cut in overall API spend — all else equal, with no changes to input rates, output rates, or cache-write prices.

Full Sonnet 5.5 pricing as of October 7, 2026

Input (non-cached)     $2.00 / MTok   — unchanged
Cache write (5 min)    $2.50 / MTok   — unchanged
Cache write (1 hr)     $4.00 / MTok   — unchanged
Cache read             $0.10 / MTok   ← was $0.20 (50% cut)
Output                $10.00 / MTok   — unchanged

How much does this actually save?

The answer depends heavily on your cache-hit ratio. A rough model: if your pipeline uses a 10K-token system prompt that is cached and re-read 100 times per session, those reads previously cost 100 × 10,000 / 1,000,000 × $0.20 = $0.20 per session. At the new rate, that is $0.10. Scale that across thousands of daily sessions and the savings are material. The developer community noted the change within hours of it going live — Anthropic's pricing page was the first confirmation, followed by SDK release notes.

🧭 Python and TypeScript SDKs Ship Typed BrowserToolset and ComputerToolset Base Classes

Also shipping on October 7: Python SDK v1.12.0 and TypeScript SDK v0.132.0 introduce typed base classes for browser use (BrowserToolset) and computer use (ComputerToolset). Until now, developers building browser-automation or desktop-control agents had to hand-wire the tool-call loop — parse the tool_use block from Claude's response, dispatch to the right handler, collect the tool_result, and feed it back in the next turn. The new classes eliminate that scaffolding: subclass the base, implement one method per tool action, and the SDK handles the rest.

What the SDK now manages for you

• Full agentic loop: The SDK iterates through multi-turn tool-call sequences until Claude returns a final text response, without any hand-written while loop in your code.
• URL and file policies: The BrowserToolset accepts a URL allowlist/blocklist and a download policy at construction time — no need to validate URLs inside your handler.
• Approval callbacks: Attach an optional on_approve callback to any toolset; the SDK will pause and call it before executing any action whose risk tier exceeds a configurable threshold (e.g. form submission, file write).
• Tool versioning: The toolset constructors accept a tool_version parameter so you can pin to browser_toolset_20260801 or computer_toolset_20260801 explicitly, decoupling your code from future default-version bumps.

Minimal Python example

from anthropic.tools import BrowserToolset, anthropic_client

class MyBrowser(BrowserToolset, tool_version="browser_toolset_20260801"):
    def screenshot(self) -> bytes:
        return capture_screen()          # your impl

    def click(self, x: int, y: int) -> None:
        driver.click(x, y)              # your impl

    def type_text(self, text: str) -> None:
        driver.type(text)               # your impl

toolset = MyBrowser(url_allowlist=["*.example.com"])
result = anthropic_client.beta.run(
    model="claude-sonnet-5-5-20260901",
    tools=toolset,
    messages=[{"role": "user", "content": "Log in and download my invoice."}],
)