The Claude 5 Family & Model Strategy

What You’ll Learn

Welcome to Module 5. The previous four modules taught you how Claude Code works as a system — the agent loop, subagents, architecture, and production patterns. This module covers what changed in the Fable 5 era, and it starts with the most visible change of all: the models themselves.

By the end of this session, you’ll know:

• The full Claude lineup as of mid-2026, with exact model IDs
• What “Mythos-class” means, and the real difference between Fable 5 and Mythos 5
• Which tier to reach for on which kind of task
• The three places you can override the model per agent
• The session dials: /model, /effort, and /fast

The Problem

For a long time, model choice in Claude Code was a single decision: pick a model at the start of the session, and everything — every message, every subagent, every background task — ran on it.

That was fine when one model was the obvious choice for everything. It stops being fine the moment your session contains tasks with wildly different needs. Consider a typical afternoon:

Task                          What it actually needs
──────────────────────────   ─────────────────────────────────
"Find every caller of X"      Speed. Cheap, mechanical search.
"Refactor this module"        Solid everyday coding capability.
"Is this migration safe?"     Maximum judgment. Get it right.

Run all three on the top tier and you burn capability (and cost) on grep-level work. Run all three on the cheap tier and you starve the one decision that actually mattered. A single session-level default forces one answer onto three different questions.

The Fable 5 era resolves this by turning the model lineup into a portfolio of tiers — and by giving you per-task control over which tier handles which work.

How It Works

The Mid-2026 Lineup

The most recent Claude models as of mid-2026:

Model	Model ID	Tier
Claude Fable 5	claude-fable-5	Mythos-class (Claude 5 family)
Claude Opus 5	claude-opus-5	Current Opus generation
Claude Opus 4.8	claude-opus-4-8	Previous Opus generation
Claude Sonnet 5	claude-sonnet-5	Sonnet-class
Claude Haiku 4.5	claude-haiku-4-5-20251001	Haiku-class

Anthropic’s guidance for builders is simple: when building AI applications, default to the latest and most capable Claude models.

The exact models and aliases you can select depend on your provider, plan, account entitlement, and rollout. Treat this as the Claude Code 2.1.226 model configuration, then confirm the choices shown by /model in your environment.

The Mythos Tier: Fable 5 and Mythos 5

Claude Fable 5 is the first model in Anthropic’s new Claude 5 family, and it belongs to a new Mythos-class tier that sits above Claude Opus in capability. “Mythos-class” is a tier name, exactly like “Opus-class” — not a separate, bigger model.

The naming trips people up, so use Anthropic’s official Fable 5 & Mythos 5 System Card as the boundary for what can be claimed:

• Anthropic describes Fable 5 and Mythos 5 as two configurations of one new large language model.
• Fable 5 is the configuration for general use, with additional safeguards for high-risk domains.
• Mythos 5 has relevant safeguards lifted and is available only to a small number of trusted partners, beginning with Project Glasswing participants.

That official description establishes a configuration, safeguards, and access distinction. Do not infer a separate larger model or broader entitlement from the names.

Capability tiers (mid-2026):

  Mythos-class   Fable 5 (generally available)
                 Mythos 5 (same base model, trusted partners only)
  ─────────────────────────────────────────────
  Opus-class     Opus 5 (current generation)
                 Opus 4.8 (previous generation)
  Sonnet-class   Sonnet 5
  Haiku-class    Haiku 4.5

Picking a Tier

Each tier has a clear job. Here is the practical selection matrix:

Task type	Reach for	Why
Architecture decisions, adversarial verification, complex multi-step autonomy, final synthesis	Fable 5	The top generally-available tier — the hardest judgment work. Ultracode is a Claude Code session orchestration mode, not a property of the model itself (more in Session 26).
Demanding Opus-class implementation and interactive coding	Opus 5	The current Opus generation; availability still depends on provider and entitlement.
Interactive work that specifically benefits from the previous Opus fast-mode path	Opus 4.8	A previous-generation Opus option with fast mode where your account exposes it.
Everyday coding	Sonnet 5	The balanced default: strong capability at mid-tier cost and latency. Successor to the Sonnet 4.x line that was long the Claude Code default.
Exploration subagents, mechanical fan-out (file reading, searching, formatting), high-volume workflow stages	Haiku 4.5	The fast/cheap tier.

Two notes on the previous Opus 4.8 option:

Fast mode. Toggled with /fast in Claude Code, fast mode uses Claude Opus with faster output. It does not downgrade to a smaller model — you get the same Opus model, faster. It’s available on Opus 4.8 and 4.7, and it’s the right setting for interactive sessions where you’re waiting on every response.

Long context. The Opus 4.x line is where Anthropic’s long-context work landed — we previously covered Opus 4.6’s 1M-token default context on this site. We won’t quote a figure for 4.8 or the Claude 5 family here.

The Three Places to Override the Model

Session-level choice is only the default. Per-agent overrides exist in exactly three places:

1. Agent type definitions — .claude/agents/*.md frontmatter. The agent registry (the same one behind the subagents you met in Session 4) defines each agent type’s model, reasoning effort, and tools. Pin a model here and every spawn of that type uses it.

2. The Agent tool’s model param — set per spawn, with the values sonnet | opus | haiku | fable.

3. Workflow agent() opts — workflow scripts (Session 27) accept model and effort per call:

// Cheap fan-out, expensive judgment
const findings = await agent(
  'List every file under src/ that touches the auth flow. Paths only.',
  { label: 'scan', model: 'haiku' }
);

const verdict = await agent(
  `Adversarially verify these findings — try to refute each one:\n${findings}`,
  { label: 'verify', model: 'fable', effort: 'xhigh' }
);

That snippet is the whole strategy in miniature: use Haiku without an effort override for mechanical stages; use an effort-capable top tier at high effort for verify, judge, and synthesis stages. Haiku 4.5 is not listed as effort-capable in the current configuration, so do not attach --effort or an effort option to it.

One discipline matters more than any override: default to omitting the override. An agent with no model set inherits the session model, which is usually correct. Override only when you’re confident a different tier fits the stage.

Session Dials: /model, /effort, /fast

Three in-session commands control the defaults:

• /model — picks the model for the session
• /effort — picks the reasoning effort (the second dial; Session 26 is devoted to it)
• /fast — toggles Opus fast mode

Both /model and /effort persist as defaults for new sessions when you choose to save them. And Claude Code itself now spans several surfaces: the CLI, the desktop app (Mac/Windows), the web app (claude.ai/code), and the IDE extensions (VS Code, JetBrains).

Hands-On Example

Let’s set up a realistic mixed-tier configuration.

Step 1: Set your session defaults.

/model     → pick Sonnet 5 for everyday coding, or Fable 5 for a hard design day
/effort    → pick a reasoning effort; save it if you want it as your standing default
/fast      → if you're on Opus 4.8 and latency is bothering you

Step 2: Pin the cheap tier where it belongs. Create an exploration agent type that always runs on Haiku, no matter what the session model is:

# File: .claude/agents/explorer.md
---
model: haiku
tools: [Read, Grep, Glob]
---

Fast, read-only codebase exploration: search, read, summarize.
Explore the codebase to answer the question you are given.
Return conclusions and relevant file paths — not raw file dumps.

Now every explorer spawn is a Haiku 4.5 run. Your session might be on Fable 5 for the architecture discussion, while five explorer subagents sweep the repo on the cheap tier in parallel.

Step 3: Leave everything else alone. For your other agent types, omit model from the frontmatter entirely. They inherit the session model — which means /model remains a single lever that moves your whole setup, except the stages you deliberately pinned.

The result is a two-speed session: judgment runs at the top of the lineup, mechanical work runs at the bottom, and one file in .claude/agents/ encodes the split permanently.

What Changed

One-Default-Model Era	Portfolio-of-Tiers Era
One model per session, chosen once	A tier per task, chosen per stage
Capability ceiling: Opus-class	Mythos-class tier above Opus (Fable 5 GA)
Subagents inherit the session model, period	Overrides in three places: agents frontmatter, Agent tool model param, workflow agent() opts
Speed meant switching to a smaller model	/fast: same Opus model, faster output
Cost control = use a cheaper session	Cost control = cheap fan-out, expensive judgment
Model choice was configuration	Model choice is strategy

The cost dimension of this shift is a direct continuation of Session 21 — the fan-out-cheap, judge-expensive pattern is cost optimization expressed as model strategy.

Key Insight

Model choice moved from per-session to per-task.

The lineup itself is easy to memorize — Fable 5 for the hardest judgment, Opus 5 as the current Opus generation, Opus 4.8 as the previous option, Sonnet 5 for balanced daily work, and Haiku 4.5 as the sprinter. The skill that actually compounds is mixing them: recognizing which stages of your work are mechanical and which are judgment, and routing each to the right tier.

And the Mythos-tier nuance is worth internalizing once, correctly: Anthropic’s 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; Mythos lifts relevant safeguards for a small set of trusted partners. The names do not establish a separate larger model or general entitlement.

Start with the inherit-by-default rule, pin Haiku where the work is mechanical, and reserve Fable 5 for the calls you can’t afford to get wrong.

Next Session

Session 26 covers Effort Levels & Ultracode — the second dial. Model choice decides which brain answers; effort decides how hard it thinks. You’ll learn the five standard effort levels (low through max), why Haiku 4.5 does not take an effort override, and why ultracode is a separate session-only xhigh-plus-workflow mode rather than another effort tier. Treat budget instructions as guidance, not a guaranteed per-turn spending ceiling.