TL;DR: Claude Opus 4.8 is the highest-scoring available coding model at 69.2% on SWE-Bench Pro, and its Fast Mode runs the same model up to 2.5× faster for exactly double the token price — $10 input / $50 output per million. It’s worth it for latency-bound work (CI-blocking review, live pair sessions), not batch jobs. For most solo coding, Sonnet 5 wins on cost.

	Opus 4.8 Fast Mode	Opus 4.8 (standard)	Claude Sonnet 5
Best for	Latency-critical agent runs, live pairing	Hardest multi-file tasks, no rush	Everyday coding on a budget
Input / Output per 1M	$10 / $50	$5 / $25	$2 / $10 intro → $3 / $15
SWE-Bench Pro	69.2%	69.2%	63.2%
Speed	up to 2.5× standard Opus	baseline	fast, not Fast-Mode fast
The catch	Research-preview waitlist; 2× the bill	Slower on long agent loops	6-point coding gap on hard tasks

Honest take: Fast Mode is the same brain as standard Opus 4.8, just delivered quicker — so pay the 2× premium only where wall-clock time costs you money. For the 90% of coding that isn’t racing a clock, put Sonnet 5 on your default hotkey and keep Opus 4.8 Fast Mode for the moments a fast, correct answer is the whole point.

What Fast Mode actually is (and isn’t)

Fast Mode is not a smaller, cheaper distilled model. It is the exact same claude-opus-4-8 weights, served on an inference path tuned to push up to 2.5× higher output tokens per second. You get identical intelligence and identical benchmark scores — 69.2% SWE-Bench Pro either way — with the tokens landing sooner. The trade is money for latency: Fast Mode bills $10 input / $50 output per million tokens, precisely double standard Opus 4.8’s $5 / $25.

That framing matters because a lot of July 2026 roundups describe Fast Mode as if it were a discount tier. It isn’t. It’s a speed tier. If your task doesn’t care how fast the answer streams — an overnight migration, a batch of test-writing, anything you kick off and walk away from — Fast Mode buys you nothing and costs you twice as much.

Anthropic shipped Opus 4.8 on May 28, 2026, and it currently sits at the top of the available-model coding leaderboard. The one score above it, Claude Fable 5’s 88.0% SWE-Bench Pro, doesn’t count for planning purposes — Fable 5 has been suspended since June 12, which is exactly why so many teams are reaching for Opus 4.8 as the go-to backend right now. Among models you can actually call today, Opus 4.8 is the benchmark leader.

The benchmark picture, verified July 6 2026

Here’s where Opus 4.8 lands against the models developers actually weigh it against. These are the numbers to anchor on, not the marketing adjectives:

Benchmark	Opus 4.8	Opus 4.7	Sonnet 5	GPT-5.5
SWE-Bench Pro	69.2%	64.3%	63.2%	58.6%
OSWorld-Verified (computer use)	83.4%	82.8%	81.2%	—

Two things stand out. First, the SWE-Bench Pro jump from 4.7 to 4.8 is 4.9 points in roughly six weeks — a real generational step on the benchmark that best proxies “can it close a hard multi-file ticket.” Second, the gap over Sonnet 5 is 6 points, which is the entire crux of the cost decision below: you’re paying 1.7× to 3.3× more per token for a 6-point coding edge.

The number that matters most for agentic work isn’t on that table, though. Anthropic reports Opus 4.8 is 4× less likely than Opus 4.7 to let a code flaw pass without flagging it. If you’ve ever watched an agent confidently ship a change with an obvious null-deref left in place, you know why that’s the headline feature for a coding backend. It’s the difference between an assistant that reviews its own work and one that just declares victory.

There’s an efficiency story too, and it cuts against the raw price. Independent analysis (Artificial Analysis) found Opus 4.8 reaches its scores using 15% fewer turns and 35% fewer output tokens per task than Opus 4.7. On CursorBench, the model exceeds every prior Opus at each effort level and is measurably less likely to skip a tool call the task actually required — the exact complaint some users had about 4.7. Fewer output tokens per task partly offsets the higher per-token rate, so the real-world gap between Opus 4.8 and cheaper models is narrower than the sticker price suggests.

Turning Fast Mode on (the step everyone misses)

Fast Mode is in research preview. You do not get it by default, and forgetting this is the number-one reason people think they enabled it but didn’t. Access is gated: contact your account manager, or join the Fast Mode waitlist if you don’t have one. Once your account is approved, two things have to be true on every request or you silently fall back to standard speed:

1. Set speed: "fast" on the request.
2. Send the beta header fast-mode-2026-02-01.

Here’s the minimal Python SDK call that proves your access works. Run this in isolation before you wire anything into an editor — it’s the cleanest way to confirm the account flag is live:

import anthropic

client = anthropic.Anthropic()
response = client.beta.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    speed="fast",
    betas=["fast-mode-2026-02-01"],
    messages=[{"role": "user", "content": "Reply with the single word: ready"}],
)
print(response.content[0].text)      # "ready"
print(response.usage.speed)          # "fast"  <-- the line that matters

The tell is response.usage.speed. If it prints standard, your request went through at the normal rate and the normal speed — either the beta header was dropped, or your account isn’t approved yet. Do not assume; check the field. Billing follows whatever usage.speed reports, so a silent fallback means you at least didn’t overpay, but you also didn’t get what you came for.

Real problem, real fix

The most common failure I’ve seen wiring this up: the request 200s, the response looks perfect, and usage.speed comes back standard. Nine times out of ten the cause is that the client library stripped an unrecognized beta string, or the code path used the stable messages.create instead of beta.messages.create. Fast Mode only exists on the beta namespace right now. Switch to client.beta.messages.create(...), keep both the speed argument and the betas list, and the field flips to fast. If it still doesn’t, your account flag isn’t live — that’s a waitlist problem, not a code problem, and no amount of header-fiddling fixes it.

Wiring it into Cursor, Cline, and Claude Code

Claude Code is the easiest path and the one most likely to Just Work, because Anthropic controls both ends. Point it at the model and flip Fast Mode mid-session with the built-in command:

claude --model claude-opus-4-8
# then, inside the session, when you hit a task that needs speed:
/fast

The /fast command toggles the current session between standard and Fast Mode on the fly — which is exactly how you should use it. Draft and explore on standard, then flip to Fast Mode for the tight iteration loop where you’re watching the output stream and every second of latency is a second you’re sitting idle.

Cline takes a Claude API key in its settings. Choose the Anthropic provider, paste your key, and select claude-opus-4-8 as the model. Cline drives the API directly, so Fast Mode activation depends on whether the version you run passes the speed/beta parameters through. As of early July 2026 that support is uneven across Cline builds — check usage.speed in a test call through your own key first, and if your Cline version doesn’t expose Fast Mode yet, you’ll get standard Opus 4.8 (which is still the top coding model, just at 1× speed).

Cursor is the fussiest of the three. Add your Anthropic key under Settings → Models, then select claude-opus-4-8. Cursor’s own routing decides whether a request goes through the Fast Mode path, and that behavior has shifted between point releases — treat Fast Mode in Cursor as “verify per version,” not “set once and trust.” When Fast Mode isn’t wired through, you still get the full-intelligence standard model; you just don’t get the 2.5× throughput you’re paying the premium for. If speed is the reason you chose Opus 4.8 at all, that distinction is the whole ballgame, so confirm it before you rely on it.

One hard limit to plan around: Fast Mode is not available on the Batch API, not available under Priority Tier commitments, and not currently available on Claude on AWS (Bedrock). If your stack routes coding traffic through Bedrock, Fast Mode is off the table today regardless of your account flag.

The cost math: is 2.5× speed worth 2× the bill?

Speed tiers only make sense once you’ve priced them against the alternative. Let’s model one moderately complex agentic task — a multi-file change where the agent re-reads context across several turns. Assume 200K input tokens billed and 25K output tokens after the dust settles (a realistic single non-trivial task, caching already applied). Here’s what that one task costs on each option:

Per task (200K in / 25K out)	Cost
Sonnet 5 (post-intro $3 / $15)	~$0.98
Opus 4.8 standard ($5 / $25)	~$1.63
Opus 4.8 Fast Mode ($10 / $50)	~$3.25

Adjust the token counts to your own workload and the ratios hold: Fast Mode is exactly 2× standard Opus, and standard Opus is roughly 1.7× Sonnet 5’s post-intro rate. Run a hundred of those tasks a month and Fast Mode is a $325 line item where Sonnet 5 is $98 — a $227 monthly difference for the same hundred tasks, bought entirely with latency.

That’s the decision in one sentence: you are paying roughly $2.30 extra per task, on this workload, to get the answer up to 2.5× sooner. Whether that’s a bargain or a waste depends entirely on what your time is doing while you wait.

Where Fast Mode earns it:

• CI-blocking review. A PR gate where every developer on the team is idle until the check returns. Shaving latency there multiplies across the whole team, and the token cost is trivial next to salaried wait time.
• Live pair-programming sessions. When you’re iterating in real time and the model’s latency is the pace of your own thinking, faster tokens keep you in flow instead of tabbing away.
• Interactive debugging where you’re firing follow-up after follow-up and each round-trip’s delay compounds.

Where it’s money lit on fire:

• Overnight migrations and batch refactors. You’re asleep. Nobody is watching the tokens stream. Use standard Opus 4.8, or route the mechanical parts to Sonnet 5. (Fast Mode is blocked on the Batch API anyway, so the platform agrees with you here.)
• Anything you kick off and walk away from. If wall-clock time has no dollar value in that moment, the speed tier has no value either.

For the honest comparison against the cheaper Anthropic model, our Claude Sonnet 5 coding review walks through where the 6-point SWE-Bench Pro gap actually shows up in real tickets — spoiler: less often than the benchmark implies, which is why Sonnet 5 is the right default for most solo work. And if you’re weighing the terminal-agent angle specifically, our Claude Code review covers how the $20–$200 subscription tiers change this math versus paying per token.

Where it breaks

No tool is all upside. Opus 4.8 Fast Mode’s honest limits:

• The preview gate is real. No account manager and a long waitlist means you may not be able to use Fast Mode at all right now, no matter how much you want to pay. Standard Opus 4.8 is available to everyone; Fast Mode is not.
• Editor support lags the API. The API had speed: "fast" before Cursor and Cline reliably passed it through. You can be paying attention to Fast Mode while your editor quietly sends standard requests. Always verify usage.speed.
• It doesn’t make a wrong answer right. Same model, same intelligence. If standard Opus 4.8 gets a task wrong, Fast Mode gets it wrong 2.5× faster and charges you double for the privilege.
• Bedrock users are out. No Fast Mode on AWS today. If that’s your platform, this entire review is about standard Opus 4.8 for you.

For the flip side of the ecosystem — what happened when Anthropic pulled a top model behind a paywall — see what Claude Fable 5 actually costs now that it’s credit-only. It’s the reason Opus 4.8 is carrying so much of the load in mid-2026.

FAQ

Is Fast Mode a different model from Opus 4.8? No. It’s the identical claude-opus-4-8 model on a faster inference path. Same weights, same 69.2% SWE-Bench Pro, same everything except throughput and price.

How do I know Fast Mode is actually on? Check response.usage.speed on the API response. It reads fast or standard. If it says standard, you’re not getting Fast Mode regardless of what you set — usually a missing beta header, a stable-namespace call instead of beta.messages.create, or an un-approved account.

Does Fast Mode cost more than standard Opus for the same task? Yes — exactly 2× on both input and output ($10/$50 vs $5/$25). You pay double for up to 2.5× faster token delivery. The task’s token count doesn’t change, only the per-token rate.

Should I use Opus 4.8 Fast Mode or Sonnet 5 for daily coding? Sonnet 5 for daily coding — it’s 63.2% SWE-Bench Pro at roughly a third the Fast-Mode price. Reach for Opus 4.8 Fast Mode when a task is both hard enough to need the 6-point edge and latency-sensitive enough to justify the premium.

Can I use Fast Mode in Cursor and Cline today? You can select claude-opus-4-8 in both. Whether the request goes through the Fast Mode path depends on your editor version passing the speed parameter and beta header. Test with your own API key and confirm usage.speed before assuming it’s active.

Is Fast Mode available on AWS Bedrock? No. Fast Mode is not currently available on Claude on AWS, and it’s also excluded from the Batch API and Priority Tier commitments.

Sources

• Introducing Claude Opus 4.8 — Anthropic
• Fast mode (research preview) — Claude Platform Docs
• What’s new in Claude Opus 4.8 — Claude Platform Docs
• Model configuration — Claude Code Docs
• Claude Opus 4.8 Benchmarks Explained — Vellum
• Claude Sonnet 5 vs Opus 4.8: agentic coding benchmarks and pricing — MarkTechPost
• Claude Opus 4.8 Launch — llm-stats.com

Last updated July 6, 2026. Pricing and features change frequently; verify current state before purchasing. Fast Mode is a research preview and access, availability, and editor support may change without notice.