Claude Opus 4.8 Released — Features, Benchmarks, and Pricing Explained

On May 28, 2026, Anthropic released Claude Opus 4.8 — barely two months after Opus 4.7. The upgrade cadence is clearly accelerating. But the headline this time is not a few percentage points on a benchmark. Anthropic's official announcement reports that early testers found the model "more reliable and sharper in its judgment when it's performing agentic tasks," and states that "one of the most prominent improvements in Opus 4.8 is its honesty." A release that puts "it became more honest" right alongside its benchmark gains is unusual.

Here is the bottom line: coding is solidly improved (SWE-bench Pro 64.3% → 69.2%), terminal work jumps (Terminal-Bench 2.1 66.1% → 74.6%), and knowledge-work scores rise too (GDPval-AA 1753 → 1890). On top of that, fast mode is roughly 2.5x faster and effectively one-third the price, and three developer-facing features land at once: the effort parameter, dynamic workflows, and system entries in the Messages API. At the same time, it does not lead everywhere — on terminal work it still trails GPT-5.5. This article breaks down the numbers, the new features, and the caveats, based on Anthropic's official announcement and its Transparency Hub.

* Figures in this article are based on Anthropic's official announcement, model page, and system card, plus reporting from multiple tech outlets (as of May 28, 2026). They may be updated as more verification comes in.

1. Opus 4.8 at a glance: performance, pricing, philosophy

For the busy reader, the essentials first.

• Performance: coding (SWE-bench Pro) is steadily stronger; terminal work (Terminal-Bench 2.1) and knowledge work (GDPval-AA) improve sharply. On the other hand, GPT-5.5 leads on Terminal-Bench 2.1, and computer use (OSWorld-Verified) barely moves.
• Pricing: standard is held flat with 4.7. The biggest economic impact is that fast mode is ~2.5x faster and effectively one-third the price.
• Philosophy: "more honest" before "smarter." It is about 4x less likely than 4.7 to let flaws in code it has written pass unremarked, and it fails to tell the user about important failures in its work only 3.7% of the time. New dynamic workflows and the effort parameter support longer autonomous work.

2. Core specs and availability

Let's start with the immovable facts: Opus 4.8's specs and where you can use it.

The key point is that price and context are held flat, and only the substance got stronger. If you are on 4.7, swapping the model ID to claude-opus-4-8 gets you the performance gains at no extra cost (migration caveats are in section 9). Just note that US-only inference carries a 1.1x pricing multiplier.

3. Benchmarks head-to-head (4.8 vs 4.7)

We saw the specs. So how much did the actual capability grow? Here are the main published benchmarks lined up against 4.7. Bold marks the biggest gains.

Source: the table (an image) in Anthropic's Opus 4.8 announcement. Terminal-Bench 2.1 scores use the Terminus-2 harness for every model; GPT-5.5 scores 83.4% with the Codex CLI harness (footnote in the same announcement). For OSWorld-Verified, the same announcement's footnote says the Opus 4.7 score was updated to 82.3% after a change in how the evaluation is run, which does not match the 82.8% in the table.

A note on reading the table. The +4.9 points on SWE-bench Pro looks modest but matters: Pro collects more realistic, harder coding tasks, so a gain there translates directly into "fewer moments where you get stuck in real work." The largest gains, though, are +8.5 points on Terminal-Bench 2.1 and +137 on GDPval-AA.

That said, it does not lead everywhere. On Terminal-Bench 2.1, GPT-5.5 is ahead at 78.2% (83.4% with the Codex CLI), and computer use on OSWorld-Verified is nearly flat versus 4.7 (+0.6 points). More in section 9.

4. Pricing and fast mode — 3x cheaper speed

We've dwelt on performance, but the thing that actually hits your wallet hardest this time is the fast mode price change. Standard pricing is completely held flat with 4.7, so let's line the two up.

This is bigger than it looks. The dilemma of "I want speed, but fast mode is pricey" hit exactly the use cases — chat-UI responses, bulk code review in CI/CD, many-step agent runs — where you can now have both speed and price. Combined with the flat standard pricing, the economic takeaway this time is "the same budget, but faster and smarter." For the full pricing picture, see Claude Opus / Sonnet / Haiku pricing comparison.

5. New feature #1: the effort parameter and adaptive thinking

After pricing, the features developers touch directly. First, the effort parameter. This is a knob that lets you explicitly specify "how deeply to think" across four levels.

The counterpart to effort is adaptive thinking: the model automatically adjusts the compute it uses according to task complexity. Quick on simple questions, deeper of its own accord on hard ones. You set the ceiling and the policy with effort, and adaptive thinking optimizes the actual allocation — a two-tier design that delivers "no wasted thinking tokens, deep only where it counts."

6. New feature #2: dynamic workflows (research preview)

The most ambitious feature this time is this one. Dynamic workflows is a research-preview feature usable in Claude Code (CLI, Desktop, VS Code extension), a mechanism for handing Claude a "big job" wholesale.

Concretely, Claude writes its own orchestration scripts and spawns tens to hundreds of parallel subagents to attack a problem concurrently. It even deploys adversarial verification agents to critically check the results, and iterates until convergence. It coordinates outside the main conversation thread, and its state is resumable, holding up across multi-day execution.

In positioning, it is a step toward having the model itself design and run, on the spot, the "parallel orchestration of many agents" you previously had to build yourself with the Claude Agent SDK. For large refactors and cross-cutting investigations, the range it can drive without step-by-step human direction expands.

7. New feature #3: system entries in the Messages API

A subtle change, but a welcome one for developers: the Messages API now accepts system entries inside the messages array.

Previously, the system prompt (system instructions) was placed once at the start of the conversation. With this change, you can inject system instructions mid-conversation — and do so without breaking the prompt cache or requiring a user turn.

// Example: updating "permissions, budget, environment" mid-workflow
messages: [
  { role: "system",    content: "You are a CI agent. No destructive operations." },
  { role: "user",      content: "Update the dependencies" },
  { role: "assistant", content: "..." },
  // Update policy mid-run (without breaking the cache)
  { role: "system",    content: "Token budget is low. Use effort=low, key points only." },
  { role: "user",      content: "Continue" }
]

This pays off in long, multi-step agent runs. "Dynamically swapping policy" mid-execution — tightening permissions, signaling token budget, updating environment context (which branch you're on, etc.) — now works while preserving cache efficiency. It's a design that pairs well with long-haul autonomous runs like dynamic workflows.

8. The biggest leap is honesty — code flaws slip by about 4x less often

This is the part I most want to convey. Opus 4.8's true differentiator is not the benchmark numbers — it is "honesty about its own work." What Anthropic and testers stressed repeatedly is that this model proactively flags its own uncertainty and is less likely to make unsupported claims.

Why does this matter? The biggest risk in letting an AI agent run autonomously for a long time is "reporting a failure as a success, then stacking more work on top of that error." Saying "fixed" while tests are still failing; stating uncertain guesses in a confident tone — this kind of "overconfidence" undermines automation reliability at the root. That Opus 4.8 now flags its uncertainty on its own is, in practical terms, more valuable than a few benchmark points. Personally, I think this single point is the most praiseworthy thing about this update.

9. Caveats (told honestly)

We've looked at the gains. But since this is an article praising "honesty," I'll be honest too — here, undisguised, are the points that did not improve or warrant caution in 4.8.

On prompt injection in particular, moving to 4.8 does not make you safer. According to Anthropic's Transparency Hub, attack success is 0.4% — the same as 4.7, over more than 15,000 attempts — the lowest among the leading models compared, but that figure is measured without the extra defenses Anthropic adds in its products. For agents that read external input (web pages, email, user posts) and act autonomously, the baseline remains a design that limits permissions rather than relying on the model's robustness.

10. Who should upgrade right now

So, should you switch to claude-opus-4-8 right now? Let's break it down by type.

Since the switching cost itself is near-zero (just change the model ID; standard pricing held flat), the royal road is to first switch to claude-opus-4-8 in a non-critical environment and measure on your own tasks. The concrete migration steps from 4.7 carry over directly from the thinking in the Opus 4.7 migration guide. For comparison with GPT-5.5 and others, see GPT-5.5 vs Claude Opus comparison.

Summary

Claude Opus 4.8 (released May 28, 2026, claude-opus-4-8) is a flagship that strengthened the substance while holding price and context flat. Coding improved steadily (SWE-bench Pro +4.9); terminal work (Terminal-Bench 2.1 +8.5) and knowledge work (GDPval-AA +137) improved sharply. Fast mode became ~2.5x faster and effectively one-third the price, and the practical features — the effort parameter, dynamic workflows, and system entries in the Messages API — all arrived together.

But the essence is not the numbers. Letting code flaws slip about 4x less often, failing to flag failures only 3.7% of the time — this release, leading with "honesty" over "smarts," points in the right direction for an era of long-running autonomous AI. At the same time, it still trails GPT-5.5 on Terminal-Bench 2.1, and its injection robustness is flat versus 4.7; it does not lead on every axis. Which is why — fittingly, in the spirit of this very model's virtue — the smartest way to engage is to not be overconfident, and to measure on your own tasks before deciding.

Related reading: Claude Opus 4.7 release breakdown, Opus 4.7 migration guide, Opus / Sonnet / Haiku pricing comparison, GPT-5.5 vs Claude Opus comparison, and What is the Claude Agent SDK.

FAQ

Q. Is migrating from Opus 4.7 to 4.8 hard?
A. It takes almost nothing. Just change the API model ID to claude-opus-4-8; standard pricing and the context window (1M tokens) are held flat. The default effort=HIGH uses roughly the same token count as 4.7's default with only performance going up, so you benefit with no config changes. For agents that handle external input, though, note that injection robustness has not improved over 4.7 (see above).

Q. What does "3x cheaper" fast mode mean?
A. It means fast mode's price ($10 input / $50 output per 1M tokens) is effectively one-third that of the previous model's fast mode. Speed is about 2.5x standard. The "I want speed but fast mode is pricey" dilemma is greatly eased, making it easier to use for chat UIs and bulk batch processing.

Q. Can anyone use dynamic workflows?
A. It is in research preview, usable from Claude Code (CLI, Desktop, VS Code extension). Availability is on Max, Team, and Enterprise plans (admin-enabled) and via the API, Bedrock, Vertex, and Foundry. For safety, the first trigger requires explicit confirmation. Behavior may change, so it's safest to try it on non-critical work first.

Q. Is 4.8 better than 4.7 in every respect?
A. No. Even in Anthropic's own table, GPT-5.5 (78.2%) is ahead of 4.8 (74.6%) on Terminal-Bench 2.1, computer use on OSWorld-Verified is nearly flat versus 4.7 (+0.6), and prompt-injection robustness is at the same level as 4.7. It is clearly ahead on coding (SWE-bench Pro), knowledge work (GDPval-AA), and honesty, but for some uses 4.7 or other models may fit better.

Q. What's the concrete benefit of higher "honesty"?
A. When running AI agents autonomously, the biggest risk is "misreporting a failure as success and stacking work on top of it." Because 4.8 lets flaws in its own code slip by about 4x less often than 4.7 and fails to tell the user about important failures only 3.7% of the time, it stops "pretending it works" and says it's uncertain when it is. For long-running automation, CI, and code review, reliability improves at a practical level.

Related: Claude Fable 5 for coding.