Claude Opus 5 Ships at Opus 4.8's Price. Speed Becomes the Upsell.

Opus 5 lands on Opus 4.8's price tag

Claude Opus 5 shipped July 24 at $5 per million input tokens and $25 per million output — identical to Opus 4.8. Anthropic frames it as coming close to Claude Fable 5's frontier intelligence "at half the price," and backs that with numbers: state-of-the-art on Frontier-Bench and GDPval-AA, more than double Opus 4.8's performance at a lower cost per task on Frontier-Bench specifically, and a score on ARC-AGI 3 that triples the next-best model's. It's now the default model on Claude Max and the strongest available on Claude Pro.

The launch landed loud: the announcement's Hacker News discussion sits at 1,768 points and 1,317 comments, and the r/ClaudeAI thread is at 2,857 upvotes and 643 comments — the kind of engagement that says this isn't a routine point release people are shrugging off.

What's more interesting than the benchmark table is what shipped alongside it, same week, from a different team.

Fast mode is the actual product move

Opus 5 ships with a Fast mode: roughly 2.5x the default speed, at 2x the base price. That's a different lever from the effort dial Sonnet 5 introduced three weeks ago — effort trades latency and tokens for reasoning depth inside a fixed price; Fast mode trades price for wall-clock speed at a fixed reasoning depth. Confusing the two will mislead your routing logic: an xhigh-effort Sonnet call and a Fast-mode Opus call solve different problems. One buys a better answer. The other buys the same answer, faster.

Here's the heuristic we use to keep them apart. Reach for effort when the failure mode is wrong — a plan that misses an edge case, a refactor that quietly breaks a contract. Reach for Fast mode when the failure mode is late — an interactive agent loop where a correct answer in 8 seconds instead of 20 is the whole product. When a task is both hard and latency-critical, you pay on both axes at once, and that is precisely the routing decision worth measuring instead of guessing at.

That distinction only matters in practice if you can actually drive it from code, tell when it's active, and cancel cleanly if it isn't behaving — which is where the SDK release comes in.

The SDK didn't wait to catch up

@anthropic-ai/claude-agent-sdk shipped 0.3.219 on July 24 — the same day as the Opus 5 launch — and 0.3.220 the next day. The headline addition is fast_mode_disabled_reason, now exposed on result and init messages, so a host application can tell a user why Fast mode isn't active instead of failing silently on it.

That one field closes a real gap. Without it, "Fast mode is on" was a hope, not a fact: a call could quietly fall back to default speed — after a model switch, under a plan that doesn't grant it, or because the request shape disqualified it — and the only signal was a latency graph that never moved. Now the reason comes back on the message itself:

// on the init/result message the SDK now hands you
if (message.fast_mode_disabled_reason) {
  telemetry.warn("fast_mode_off", { reason: message.fast_mode_disabled_reason });
}

Log it, don't swallow it. The difference between a debuggable primitive and a checkbox feature is whether that string ever reaches a dashboard.

Paired with it: an opt-in cancel_queued flag on the interrupt control request, which cancels queued and pending-dispatch messages alongside an abort — previously, aborting mid-stream on a Fast-mode call could leave queued messages in an ambiguous state, sitting dispatched against a model that was supposed to have stopped. The same release also fixed the initialize response reporting fast_mode_state from the spawn-time model after a model switch — the exact bug you would trip over building the routing logic above.

Two smaller additions in the same pair of releases are worth flagging if you're maintaining an agent host: a DirectoryAdded lifecycle hook fired when a new working directory registers mid-session, and a sandbox.network.strictAllowlist setting for deterministically denying non-allowlisted hosts in sandboxed commands. Neither is Opus-5-specific, but both landed in the same 48-hour window as the model launch — that reads less like a coincidence and more like a release calendar synced to it.

Two quiet betas worth knowing about

Buried below the benchmark charts, Anthropic's launch post confirms two beta features that matter more for production agent code than the headline numbers: mid-conversation tool changes on the Claude Platform, where developers can now swap which tools Claude has access to without invalidating the prompt cache, and automatic fallbacks, where requests flagged by safety classifiers on Opus 5 or Fable 5 can route to another model instead of failing the call outright. Both are the kind of unglamorous plumbing that decides whether "swap models based on task" stays a routing diagram on a whiteboard or actually ships to production. The tool-swap-without-cache-invalidation one is quietly the bigger deal: it removes the tax that made dynamic tool sets too expensive to bother with in long-running agents.

Meanwhile, open-weight labs are pricing the same axis

Three days before Opus 5 shipped, Mira Murati's Thinking Machines Lab released Inkling — a 975-billion-parameter mixture-of-experts model (41B active), full weights on Hugging Face under Apache 2.0, a 1M-token context window, pretrained on 45 trillion tokens of text, images, audio, and video. It's the lab's first public model since Murati left OpenAI, and it's live on OpenRouter at $1 per million input tokens and $4.05 per million output — roughly a fifth of Opus 5's input price.

What stands out isn't Inkling's general performance, which trails smaller, cheaper models on several factuality benchmarks in Thinking Machines' own comparison chart. It's the agentic-specific number: 74.1 on MCP Atlas, a benchmark scoring how reliably a model completes real tasks through the Model Context Protocol. That clears Nvidia's Nemotron 3 Ultra (42.7) by more than 30 points — though it still trails Zhipu's GLM 5.2 (77.8) on the same metric. Thinking Machines chose to lead its launch with that number instead of a general leaderboard rank, which on its own tells you where the open-weight competition thinks the next fight is.

Read the two launches together and a pattern shows up: nobody is shipping "smarter" as one number anymore. Anthropic is pricing speed as a separate axis from reasoning depth. Thinking Machines is optimizing and marketing a model specifically for agentic tool-use, general performance be damned. The model card is starting to look like a spec sheet with independent dials, not a single IQ score — and routing logic that still treats "which model" as one decision is going to be wrong more often from here.

What we're betting on next week

We're watching whether fast_mode_disabled_reason actually surfaces useful denial reasons in practice, or just becomes another string swallowed in a catch block — that's the difference between a debuggable primitive and a checkbox feature. On personal dev infra, we're testing whether Fast mode earns its 2x price premium specifically on tight-latency agentic loops, versus staying on default-speed Opus 5 for everything else. And if the MCP Atlas framing catches on, expect more open-weight labs to follow Inkling's lead and market an agentic-specific number instead of a general leaderboard rank.

The takeaway for anyone shipping agents: "which model" is no longer one decision. It's a model, an effort level, a speed tier, and a fallback policy — four dials, priced independently. The teams that treat it that way will spend less and ship faster than the ones still picking a single name off a leaderboard.

→ get in touch