Part ofClaude Models Explained: Opus vs Sonnet vs Haiku
Claude Opus 4.8 is Anthropic's flagship model for hard reasoning and agentic coding: the benchmarks, $5/$25 pricing, 1M context, and when to pick it over Sonnet.
In This Article
7 sectionsClaude Opus 4.8 is Anthropic's flagship large language model, released May 28, 2026, built for the hardest reasoning and agentic coding. It tops the SWE-bench Pro benchmark at 69.2%, costs $5 per million input and $25 per million output tokens, and holds up to a 1-million-token context window with an adaptive thinking mode you switch on per request.
We've spent weeks running the model across production coding work on this site, and this review covers what it actually is, where it leads, what it costs, and when the flagship earns its price over a cheaper Sonnet model. If you want the whole family mapped first, our Claude models explained guide lays out every tier.
What is Claude Opus 4.8?
Claude Opus 4.8 is Anthropic's premium, top-tier model — the most capable rung of a lineup that also includes the mid-tier Sonnet and the fast, cheap Haiku. Released May 28, 2026, it builds directly on Opus 4.7 with better judgment, cleaner tool use, and noticeably stronger agentic coding. Anthropic introduced it as a model tuned for software engineering and high-stakes enterprise work rather than casual chat.
You reach it as the model ID claude-opus-4-8 on the Claude API, or inside Claude for Pro, Max, Team, and Enterprise plans. It's also generally available on Amazon Bedrock, Google Cloud, Microsoft Foundry, and GitHub Copilot, so most enterprise stacks can call it without leaving their existing cloud. Two things define the release: a 1-million-token context window by default and an adaptive thinking mode that lets the model reason before it answers.
Claude Opus 4.8 benchmarks: where it leads
On paper the jump from 4.7 looks incremental; on the hardest tests it isn't. The headline is SWE-bench Pro, the industry's toughest agentic software-engineering benchmark, where Claude Opus 4.8 scores 69.2% — almost five points clear of Opus 4.7 and more than ten points ahead of the nearest competitor. It was also, on Anthropic's Super-Agent benchmark, the only model to complete every case end-to-end.
| Benchmark | Opus 4.8 | Opus 4.7 | What it measures |
|---|---|---|---|
| SWE-bench Pro | 69.2% | 64.3% | Real-world agentic software engineering |
| GDPval-AA (Elo) | 1890 | 1753 | Economically valuable knowledge work |
| USAMO | 96.7% | 69.3% | Olympiad-level math reasoning |
| GraphWalks @ 1M tokens | 68.1% | 40.3% | Tracking facts across long context |
The pattern is clear: the biggest gains land on tasks that demand sustained reasoning — long-context tracking nearly doubled, and competition math jumped almost thirty points. For everyday questions you won't feel the difference. For multi-hour agent runs and dense codebases, you will. Anthropic's what's-new documentation lists the full scorecard and the max 128k output ceiling.
Claude Opus 4.8 pricing and Fast Mode
Pricing didn't move. Claude Opus 4.8 costs $5 per million input tokens and $25 per million output tokens — identical to Opus 4.5 and 4.7 — so the upgrade is free in every sense but the compute you already pay for. Two levers cut that further: prompt caching saves up to 90% on repeated context, and the Batch API halves the bill for non-urgent jobs. Our Claude API pricing breakdown has the full math.
| Mode | Input / 1M | Output / 1M | Notes |
|---|---|---|---|
| Standard | $5 | $25 | Same price as Opus 4.5 and 4.7 |
| Fast Mode | $10 | $50 | ~2.5x speed, 3x cheaper than earlier Fast Mode |
| Prompt caching | up to 90% off | — | On cached input reads |
| Batch API | 50% off | 50% off | Async, non-urgent workloads |
Fast Mode is the quiet win. It runs the model at roughly 2.5 times normal speed for $10 input and $50 output per million tokens — three times cheaper than Fast Mode was on previous Claude models. For latency-sensitive agent loops, that changes the economics of using a flagship model at all.
Effort levels and adaptive thinking
A defining feature of this release is explicit control over how hard the model thinks. Claude Opus 4.8 exposes five named effort levels that trade latency for depth, and the default is High everywhere — the API, claude.ai, and Claude Code.
| Effort level | Reach for it when |
|---|---|
| Low | Quick lookups, formatting, simple edits |
| Medium | Everyday knowledge work — the practical default |
| High | Default: coding, analysis, most agent tasks |
| Max | Hard, multi-step problems worth the wait |
| Ultra Code | The most demanding unattended engineering |
Thinking itself is separate and off by default. To make the model reason before answering, set thinking: {type: 'adaptive'} in your API request. One gotcha catches everyone: the model rejects the temperature, top_p, and top_k parameters — they return errors — so you steer behavior through prompting instead. Our extended thinking guide covers when the reasoning tokens are worth paying for, and the context window explainer covers how far 1M tokens actually stretches.
When to use Claude Opus 4.8 instead of Sonnet
The flagship isn't always the right call. Sonnet 5 is faster and costs $2 per million input and $10 output — a fraction of Opus — and handles most day-to-day work without blinking. We default to Sonnet and escalate to Opus only when a task genuinely needs the extra reasoning. Our Sonnet vs Opus comparison goes deeper, but the short version fits in a table.
| Reach for Claude Opus 4.8 | Reach for Sonnet |
|---|---|
| Multi-hour, unattended agent runs | Interactive, single-turn coding |
| Dense legacy codebases and big refactors | Well-scoped feature work |
| High-stakes analysis where errors are costly | Drafting, summarizing, routine Q&A |
| Problems where 4.7 kept failing | Anything latency- or budget-sensitive |
The honest rule we follow: if Sonnet solves it in two tries, keep using Sonnet. When the same prompt fails repeatedly or the job runs for hours untouched, the accuracy of the flagship pays for its price.
Claude Opus 4.8 review: real strengths and honest limits
After weeks of daily use, here's our candid Claude Opus 4.8 review. The strengths are real: it follows instructions consistently across long, unattended engineering sessions, carries context and style better than 4.7 across a full session, and it's faster despite thinking harder. Simon Willison called it "a modest but tangible improvement," and that matches our experience — the comment-verbosity and tool-calling quirks of Opus 4.7 are largely gone.
Coding is where the model separates from the pack. It's built for complex agentic work — planning a change, editing across files, running tests, and fixing what breaks — and it holds instructions steadily enough for unattended engineering that runs without a human watching each step. That reliability is why it shipped generally available in GitHub Copilot on launch day, and why we hand it our gnarliest refactors. On Anthropic's Super-Agent benchmark it was the only model to finish every case from start to finish.
The limits are just as real. At $5/$25 it's the most expensive model in the family, so pointing it at trivial tasks burns money for no benefit. Like every Claude model, it does not generate images — it can analyze them, but image creation isn't a feature, so don't expect it. And because thinking is off by default, teams sometimes benchmark Opus 4.8 without it and wonder why the reasoning gains didn't show up. Where this version fits in the broader arc of the line is worth understanding too; our Opus release history traces every release.
The quick version:
- Tops SWE-bench Pro at 69.2% for agentic coding
- Best for the hardest reasoning and big refactors
- Costs $5 in / $25 out per million tokens
- Reach for it only when Sonnet 5 falls short
Claude pricing at a glance
| Plan | Price |
|---|---|
| Free | $0 |
| Pro | $20 / month |
| Max | from $100 / month |
| API | Pay per token |
For the full breakdown of every plan, see our how much Claude costs guide.
Frequently Asked Questions

Written by
InnovateTechie
Writing about Claude and the Anthropic toolkit — models, Claude Code, pricing, features, and fixes, in clear, practical, hands-on guides tested by daily use.
View all posts →





