Which Claude Model Should You Use in 2026? Fable 5, Opus 5, Sonnet 5 & More

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 and generations — Fable 5, Opus 5, the previous Opus 4.8, Sonnet 5, and Haiku 4.5 — plus three separate places to override the model per task, a /fast mode for supported Opus work, and an /effort dial for effort-capable models.

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 5	`claude-opus-5`	Current Opus generation
Claude Opus 4.8	`claude-opus-4-8`	Previous Opus generation; supports fast mode where available
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

This is the Claude Code 2.1.226 model configuration. Which models and aliases appear in /model can vary by provider, plan, account entitlement, and rollout, so treat your active selector as the final availability check.

One structural change worth internalizing: Fable 5 is the first model in the Claude 5 family, in a new Mythos-class tier. Anthropic’s official system card describes Fable 5 and Mythos 5 as two configurations of one new large language model: Fable is for general use with additional safeguards, while Mythos lifts relevant safeguards for a small set of trusted partners. That supports a configuration-and-access distinction, not an inference that Mythos is a separate “bigger” model or generally entitled. 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. 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 5 — the current Opus generation

Opus 5 is the current Opus-class option in Claude Code’s model configuration. Reach for it when you want demanding Opus-class implementation or interactive coding, subject to the models exposed by your provider and account.

Opus 4.8 — the previous Opus generation

Opus 4.8 remains a previous-generation Opus option, and it supports fast mode where available. 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. Choose it when you specifically need this supported previous-generation path and your account exposes it; do not treat it as the latest Opus generation.

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:

/fast toggles fast mode in Claude Code.
Fast mode uses Claude Opus with faster output.
It does not downgrade you to a smaller model.
It is documented for Opus 4.8 and 4.7, subject to the models and entitlements your account exposes.

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. Use Sonnet 5 for everyday work and Opus 5 for demanding Opus-class work. If your environment still exposes Opus 4.8 and its fast mode, that previous-generation path remains useful when latency matters. 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	Opus 5	Current Opus generation, when available to the account
Latency-sensitive work on the supported previous path	Opus 4.8 + `/fast`	Previous Opus generation 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	Reserve the generally available top tier for costly judgment
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 without an effort override
const summaries = await parallel(modules.map(m => () =>
  agent(`Summarize the public API of ${m}: exports and signatures.`, {
    label: `scan ${m}`,
    model: 'haiku',
  })
));

// 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. For models listed as effort-capable, /effort has five standard values — low / medium / high / xhigh / max — and workflow scripts can set supported values per subagent. Fable 5, Opus 5, Sonnet 5, and Opus 4.8 support all five in Claude Code 2.1.226. Haiku 4.5 is not listed as effort-capable, so use it without --effort or an effort option. Ultracode is not a sixth effort tier: it is a session-only mode that combines xhigh with workflow orchestration and resets when the session ends.

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 without an effort override; Fable 5 decides what the findings mean. Sonnet 5 handles the everyday middle, Opus 5 is the current Opus option for demanding work, and the previous Opus 4.8 remains a fast-mode path where available. 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

Route by role and generation: Fable 5 for the hardest judgment, Opus 5 as the current Opus generation, the previous Opus 4.8 only when that path fits, Sonnet 5 for everyday coding, and Haiku 4.5 for fan-out.
Fast mode is faster Opus, not smaller Opus — /fast is documented for Opus 4.8/4.7, subject to availability.
Three override points: agent frontmatter, the Agent tool’s model param, and workflow agent() opts.
Inherit by default — only pin a model when you’re confident the tier fits.
Effort is model-specific — capable models expose five standard levels; Haiku 4.5 does not, and ultracode remains a separate session mode.

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.