Which Claude Model Should You Use in 2026? Fable 5, Opus 4.8, Sonnet 5 & Haiku 4.5
Practical guide to choosing between Claude Fable 5, Opus 4.8, Sonnet 5, and Haiku 4.5 in Claude Code — plus fast mode, tier mixing, and effort levels.
For years, picking a Claude model was a one-time decision: you set a default, and every task in the session used it. In mid-2026, that mental model is obsolete. Claude Code now gives you a portfolio of tiers — Fable 5, Opus 4.8, Sonnet 5, and Haiku 4.5 — plus three separate places to override the model per task, a /fast mode for latency-sensitive Opus work, and an /effort dial layered on top.
This guide covers what each tier is actually for, when to reach for which, and how to mix them so your expensive tokens go where judgment matters and your cheap tokens do the grunt work.
The 2026 Lineup at a Glance
As of mid-2026, the current Claude models are:
| Model | Model ID | Position |
|---|---|---|
| Claude Fable 5 | claude-fable-5 | Mythos-class tier, above Opus — top generally available model |
| Claude Opus 4.8 | claude-opus-4-8 | Frontier Opus-class workhorse, supports fast mode |
| Claude Sonnet 5 | claude-sonnet-5 | Balanced default for everyday coding |
| Claude Haiku 4.5 | claude-haiku-4-5-20251001 | Fast/cheap tier for fan-out and mechanical work |
One structural change worth internalizing: Fable 5 is the first model in the Claude 5 family, and it sits in a new Mythos-class tier above Opus. Its sibling, Mythos 5, is the same underlying model without Fable’s additional dual-use safety measures, available only to approved organizations — it is not a “bigger” model. If you want the full story of the tier split, read our Fable 5 & Mythos 5 explainer.
Anthropic’s own guidance for building AI applications is to default to the latest and most capable Claude models. For day-to-day Claude Code use, though, “most capable everywhere” is rarely the efficient answer. Here’s how the tiers actually break down.
Per-Tier Profiles
Fable 5 — the judgment tier
Fable 5 is the top generally available tier, and it’s the model that ships with ultracode-style orchestration guidance. Use it for the hardest judgment work:
- Architecture decisions — where a wrong call is expensive to unwind
- Adversarial verification — refuting plausible-but-wrong findings
- Complex multi-step autonomy — long tasks where the model must self-correct
- Final synthesis — merging many agents’ outputs into one coherent answer
If a task’s cost is dominated by being wrong rather than by tokens, this is the tier.
Opus 4.8 — the frontier workhorse
Opus 4.8 is the frontier Opus-class model, and it has one feature no other tier offers: fast mode. The Opus 4.x line is also where Anthropic’s long-context work landed — we covered Opus 4.6’s 1M-token default when it shipped — though we won’t claim specific context sizes for 4.8 here. Reach for Opus 4.8 when you want frontier capability in an interactive session, especially with /fast on.
Sonnet 5 — the everyday default
Sonnet 5 is the balanced choice: strong capability at mid-tier cost and latency. It’s the successor to the Sonnet 4.x line that was long the Claude Code default, and for most feature work, refactoring, and debugging it remains the sensible session model — for everyday coding, that’s fine.
Haiku 4.5 — the fan-out engine
Haiku 4.5 is the fast/cheap tier, and its sweet spot is volume: exploration subagents, mechanical fan-out stages (file reading, searching, formatting), and high-throughput workflow stages. You almost never want Haiku as your main session model — you want it as the model your subagents run on while your main session stays on something heavier.
Fast Mode: Faster Opus, Not a Smaller Model
This is the most commonly misunderstood feature of the lineup, so let’s be precise:
/fasttoggles fast mode in Claude Code.- Fast mode uses Claude Opus with faster output.
- It does not downgrade you to a smaller model.
- It’s available on Opus 4.8 and 4.7.
The mental model: fast mode trades nothing on which model you’re talking to — it’s the same Opus, with faster output. Use it in interactive sessions where latency matters: pair-programming loops, rapid iterate-and-check cycles, anywhere you’re waiting on the model more than thinking between turns.
A Decision Framework
Four common working modes, and where each tier fits:
1. Interactive coding. You’re in the loop, reviewing every change. Sonnet 5 for everyday work; Opus 4.8 with /fast when the problem is hard and you’re latency-sensitive. Switch mid-session with /model — your choice can be saved as the default for new sessions.
2. Exploration. Mapping an unfamiliar codebase, finding files, tracing usages. This is subagent territory, and it’s Haiku 4.5 territory: spawn cheap explorers, keep conclusions (not file dumps) in your main context. See Session 4: Subagents & Context Isolation for the delegation pattern.
3. Verification. Checking whether findings are real, judging competing outputs, refuting your own conclusions. This is where skimping backfires — a verifier that rubber-stamps everything is worse than no verifier. Use the top tier at high effort.
4. Autonomy. Long-running, multi-step tasks where nobody’s watching each step. The model needs to notice its own mistakes, so complex multi-step autonomy is Fable 5’s home turf.
The selection table
| Task type | Model | Why |
|---|---|---|
| Everyday feature work, debugging | Sonnet 5 | Strong capability at mid-tier cost/latency |
| Hard interactive problems, latency-sensitive | Opus 4.8 + /fast | Frontier Opus with faster output — same model |
| Codebase exploration (subagents) | Haiku 4.5 | Fast/cheap; built for search-and-read fan-out |
| Mechanical stages: formatting, file scans | Haiku 4.5 | High volume, low judgment — don’t overpay |
| Architecture decisions, final synthesis | Fable 5 | Top GA tier; wrong answers cost more than tokens |
| Adversarial verification, judge panels | Fable 5 (high effort) | Refutation quality is the whole point |
| Complex multi-step autonomy | Fable 5 | Ships with ultracode-style orchestration guidance |
| Subagents, when unsure | (no override) | Inherit the session model — the safe default |
Mixing Tiers: The Three Override Points
Here’s the real skill of the 2026 lineup: you don’t pick a model, you pick a model per role. Claude Code exposes per-agent model overrides in exactly three places.
1. Agent definitions (.claude/agents/*.md)
Every agent type in your registry can pin its own model, reasoning effort, and tools in frontmatter. The classic move — a permanent cheap explorer:
---
name: explorer
description: Read-only codebase exploration. Finds files, maps structure, reports back.
tools: Read, Grep, Glob
model: haiku
---
Explore broadly, then return a short summary of conclusions.
Never modify files.Now every spawn of explorer runs on Haiku 4.5, regardless of what your session is using.
2. The Agent tool’s model parameter
When spawning a one-off subagent, the Agent tool accepts a model parameter: sonnet | opus | haiku | fable. This is the ad-hoc version of the same idea — no registry entry needed.
3. Workflow agent() opts
Inside Workflow orchestration scripts, every agent() call takes model and effort options. This is where tier mixing becomes systematic — cheap fan-out feeding expensive judgment:
// Cheap mechanical stage: scan every module on Haiku, low effort
const summaries = await parallel(modules.map(m => () =>
agent(`Summarize the public API of ${m}: exports and signatures.`, {
label: `scan ${m}`,
model: 'haiku',
effort: 'low',
})
));
// Expensive judgment stage: one Fable 5 synthesis at xhigh effort
const review = await agent(
`Here are API summaries for every module:\n` +
summaries.filter(Boolean).join('\n') +
`\nIdentify inconsistencies and propose a unified naming scheme.`,
{ label: 'synthesize', model: 'fable', effort: 'xhigh' }
);See Session 27: The Workflow Tool for the full orchestration model.
One rule ties all three together: default to omitting the override. An agent with no model set inherits the session model, and that’s the right call unless you’re confident a different tier fits. Pinning models everywhere is premature optimization — pin the clear wins (Haiku for exploration, top tier for judgment) and leave the rest alone.
Effort: The Second Dial
Model choice is only half the control surface. /effort sets reasoning effort for the session — low / medium / high / xhigh — and workflow scripts can set it per subagent (including a max tier). The same pairing logic applies: cheap mechanical stages get low effort, hard verify/judge stages get the high tiers. And at the very top sits ultracode: xhigh effort plus standing workflow orchestration, opt-in because of the scale it unlocks.
That’s a full article of its own — see Ultracode & Effort Levels: Turning Claude Code Up to Eleven.
The Cost Strategy in One Sentence
Cheap fan-out, expensive judgment.
Every pattern in this guide is a variation of that sentence. Haiku 4.5 agents read a hundred files; Fable 5 decides what the findings mean. Sonnet 5 handles the everyday middle; Opus 4.8 with /fast covers the hard-and-interactive corner. The waste in most setups isn’t using expensive models — it’s using them for work that never needed judgment in the first place. (For the broader token-budget picture, Session 21: Cost Optimization still applies.)
Takeaways
- Four tiers, four jobs: Fable 5 for judgment, Opus 4.8 for frontier interactive work, Sonnet 5 for everyday coding, Haiku 4.5 for fan-out.
- Fast mode is faster Opus, not smaller Opus —
/fast, available on Opus 4.8/4.7. - Three override points: agent frontmatter, the Agent tool’s
modelparam, and workflowagent()opts. - Inherit by default — only pin a model when you’re confident the tier fits.
- Effort is the second dial — pair low effort with cheap stages, high tiers with judgment stages.
Model choice moved from per-session to per-task. Once you internalize that, /model, /effort, and /fast stop being settings and start being part of how you work.
Want the hands-on version? Work through Session 25: The Claude 5 Family & Model Strategy in our tutorial series.