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 4.8	claude-opus-4-8	Opus-class
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 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 here is the precise relationship:

• Fable 5 and Mythos 5 share the same underlying model.
• Fable 5 is Anthropic’s most intelligent generally available model. It includes additional safety measures for dual-use capabilities.
• Mythos 5 is the same model without those measures, available only to approved organizations.

The difference is availability and safety configuration — not size, not intelligence.

Capability tiers (mid-2026):

  Mythos-class   Fable 5 (generally available)
                 Mythos 5 (same model, approved orgs only)
  ─────────────────────────────────────────────
  Opus-class     Opus 4.8
  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. It’s also the model that ships with ultracode-style orchestration guidance (more in Session 26).
Interactive frontier coding where latency matters	Opus 4.8	The frontier Opus-class workhorse, with fast mode support.
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 Opus 4.8:

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', effort: 'low' }
);

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: cheap models and low effort for mechanical stages; the top tier and high effort for verify, judge, and synthesis stages.

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 on top, Opus 4.8 the workhorse, Sonnet 5 the default, Haiku 4.5 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: Fable 5 and Mythos 5 are the same underlying model. One is generally available with additional dual-use safety measures; the other drops those measures for approved organizations. Tier names describe capability classes — they don’t imply a secret bigger model behind the curtain.

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 four effort levels, what ultracode actually enables, and how token budget directives put a hard ceiling on a turn’s spend.