Claude Products Bench Score Report: A Field Guide to Anthropic's 2026 Model Lineup
Published July 2026*
Anthropic's model lineup has grown wide enough that "just use Claude" is no longer a complete answer — the real question is *which* Claude, at *what* effort setting, for *what* job. This report scores every currently active Claude model across the dimensions that actually matter when you're shipping a product: raw capability, agentic/coding strength, cost efficiency, context handling, and operational maturity (API surface, tooling, availability). Scores are out of 10, benchmarked relative to the current lineup rather than against competitors.
| Model | Capability | Agentic/Coding | Cost Efficiency | Context/Output | Maturity | Overall | |---|---|---|---|---|---|---| | Claude Fable 5 | 10 | 10 | 4 | 9 | 8 | 9.1 | | Claude Opus 4.8 | 9 | 9.5 | 6 | 9 | 10 | 8.9 | | Claude Opus 4.7 | 8.5 | 9 | 6 | 9 | 9.5 | 8.4 | | Claude Sonnet 5 | 8.5 | 9 | 8.5 | 9 | 9 | 8.8 | | Claude Opus 4.6 | 8 | 8 | 6 | 8.5 | 8.5 | 7.8 | | Claude Sonnet 4.6 | 7.5 | 7.5 | 8.5 | 8.5 | 9 | 8.1 | | Claude Haiku 4.5 | 6.5 | 6 | 10 | 6.5 | 9 | 7.4 |
Overall is a weighted blend favoring capability and cost-efficiency, since those are the two axes that most determine "should I actually use this."*
This isn't a leaderboard scrape — it's a synthesis of Anthropic's own published positioning, current pricing, context/output limits, and API capability surfaces (thinking modes, effort control, fast mode, task budgets, tool ecosystem) as of the current model catalog. Each dimension is scored as follows:
Capability — general reasoning, knowledge work, vision, long-horizon judgment. - Agentic/Coding — tool use, autonomous multi-step execution, code generation and review, subagent delegation. - Cost Efficiency — output quality per dollar, not absolute price (a cheap model that fails the task scores low here). - Context/Output — context window size and max output tokens, since these gate what workloads are even possible. - Maturity — API stability, feature completeness (structured outputs, prompt caching, effort control), platform availability (Bedrock/Vertex/Foundry/AWS).
Fable 5 is Anthropic's most capable widely released model, built for the hardest reasoning and the longest-horizon agentic work — the kind of task where a single request might legitimately run 15 minutes because the model is gathering context, building, and self-verifying before it answers. Thinking is *always on* here; you don't toggle it, you tune its depth with `effort` (low through max). It's the first model class where "give it your hardest unsolved problem first" is genuinely the right move rather than marketing copy — reliable parallel sub-agent delegation, first-shot implementation of well-specified systems, and enterprise-deliverable generation (spreadsheets, slides, financial models) are where it separates from the pack.
The catch is exactly what you'd expect: it's priced above Opus tier, and turns are long enough that you need to architect around it — streaming, async check-ins, progress UX. It also demands 30-day data retention (no zero-retention orgs allowed), and safety classifiers can trigger `stop_reason: "refusal"` on cyber/bio-adjacent work, so production code should ship with fallback handling from day one.
Best for: the 5% of tasks where quality genuinely bottlenecks the business — hard bug hunts, greenfield system builds, autonomous overnight runs. Skip if: you're doing routine chat, classification, or anything latency-sensitive.
This is the model Anthropic tells you to reach for unless you have a specific reason not to — and the scorecard agrees. Opus 4.8 is the most capable Opus-tier model: state-of-the-art long-horizon agentic execution, strong knowledge work, and a notably warmer, clearer writing voice than its predecessor. It keeps the exact same API surface as Opus 4.7 (no new breaking changes), so upgrading is a model-ID swap plus some prompt re-tuning, not a migration project.
Two things make it operationally attractive beyond raw quality: fast mode (up to 2.5x output tokens/sec at premium pricing, exclusive to the 4.8/4.7 tier) and a full 1M-token context window at *standard* pricing — no long-context premium. It's also more conservative than you'd expect about reaching for tools, subagents, and memory by default, which means prompts should explicitly state *when* to delegate rather than assuming the model will infer it.
Best for: general-purpose default across coding, agents, and knowledge work — this is the "just use this" answer for most teams.
Sonnet 5 is the standout on cost-efficiency: it reaches what was previously Opus-tier quality on coding and agentic benchmarks at roughly 60% of Opus 4.8's price, with an introductory rate through August 2026 that pushes the value proposition even further. It's the first Sonnet-tier model to get the full `xhigh` effort level and high-resolution vision (2576px), closing much of the capability gap that used to separate the two tiers.
The migration wrinkle worth knowing: Sonnet 5 uses a new tokenizer that produces roughly 30% more tokens for the same text versus Sonnet 4.6, and adaptive thinking is now *on by default* (previously off by default when `thinking` was omitted) — both change your cost math even though per-token pricing is unchanged. Budget and `max_tokens` limits tuned for 4.6 need re-baselining.
Best for: production workloads at scale where Opus-level output matters but Opus-level spend doesn't pencil out — this is the highest-leverage model in the lineup right now.
Opus 4.7 was the most capable model at its launch and remains a strong, mature choice — highly autonomous, excellent on long-horizon agentic work, vision, and memory tasks. It introduced high-resolution vision (2576px long edge, automatic, no beta flag) and the `xhigh` effort tier that's now standard across the newer models. Since Opus 4.8 has an identical request surface and no new breaking changes, there's little reason to specifically target 4.7 for new work — but existing 4.7 integrations don't need urgent migration either.
Best for: teams already stable on 4.7 who aren't yet prioritizing the upgrade cycle; new integrations should default to 4.8 instead.
Opus 4.6 introduced adaptive thinking and remains fully functional, but it's now two generations behind the frontier within its own tier. It still supports the deprecated `budget_tokens` manual thinking control as a transitional escape hatch, which is useful only if you're mid-migration and need a hard token ceiling before tuning `effort`. Otherwise, there's no reason to start new work here — Sonnet 5 beats it on cost-efficiency and Opus 4.8 beats it on everything else.
Best for: legacy integrations not yet migrated. New builds should skip straight past this one.
Sonnet 4.6 was the prior generation's best price/performance pick, and it's still a perfectly competent model for chat, summarization, and moderate agentic work. It defaults to `high` effort (a change from Sonnet 4.5's no-effort baseline that catches migrators off guard on latency/cost). With Sonnet 5 now shipping at introductory pricing and materially better coding/agentic performance, 4.6's value case has mostly evaporated — it's a hold-steady option, not a first choice for new projects.
Best for: cost-sensitive workloads already built on 4.6 where migration hasn't been prioritized yet.
Haiku 4.5 is not trying to compete on the capability axis, and scored accordingly — but it dominates cost-efficiency and is the right call for high-volume, latency-sensitive, low-complexity work: classification, simple extraction, chat routing, moderation triage. Its context window (200K) and max output (64K) are noticeably smaller than the rest of the lineup, and it doesn't support the highest effort tiers (`xhigh`/`max` aren't available). Rate limits also live in a separate pool from the older Haiku 3.x line, so teams migrating up need to check their tier headroom before ramping traffic.
Best for: high-throughput, simple tasks where Opus/Sonnet-level reasoning would be wasted spend.
| If you need... | Use | |---|---| | The best possible answer, cost be damned | Fable 5 | | A strong default for coding/agents in production | Opus 4.8 | | Best cost-to-quality ratio at near-Opus performance | Sonnet 5 | | Fastest response time at premium cost (fast mode) | Opus 4.8 with `speed: "fast"` | | High-volume classification, routing, simple extraction | Haiku 4.5 | | Long-horizon autonomous agent runs | Fable 5 or Opus 4.8 | | Budget-constrained production chat/summarization | Sonnet 5 (intro pricing) or Sonnet 4.6 |
1. Adaptive thinking has fully replaced manual token budgets. `budget_tokens` is deprecated-to-removed across the entire current generation (Fable 5, Opus 4.7/4.8, Sonnet 5 all reject it outright; only Opus 4.6/Sonnet 4.6 still accept it as a transitional escape hatch). `effort` (low → max) is now the primary depth-of-reasoning lever. 2. The tier gap is narrowing. Sonnet 5 getting `xhigh` effort and high-res vision means the historical "Sonnet is the compromise tier" framing is weaker than it's ever been — for a lot of coding and agentic work, Sonnet 5 at `xhigh` closes most of the distance to Opus. 3. Cost efficiency and raw capability are now genuinely decoupled. Fable 5 sits at the top of capability and near the bottom of cost-efficiency by design — it's a deliberate ceiling model, not a default. 4. Context windows have converged at 1M across every current-generation model except Haiku 4.5 (200K) — the differentiator is no longer "how much can it hold" but "how well does it reason over what it holds," which is exactly where the capability scores diverge.
Pricing and specs current as of the latest model catalog. Model capabilities, especially around effort tiers and fast mode, are evolving quickly — verify against Anthropic's live documentation before making procurement decisions.*