Fable 5 Advisor + Sonnet 5 Executor: Claude Code Setup, Prompts, and When to Consult

Update — July 24, 2026: ClaudeDevs' zoom / crop cookbook — Fable 5 Chartography 29%→73% with a full-res lean-in tool. Pair with this advisor/executor split when vision QA is the bottleneck.

Update — July 22, 2026: Cursor's swarm research puts the same planner/worker split on a SQLite rebuild — Opus+Composer ≈ $1.3k vs all-GPT-5.5 ≈ $10.5k at similar quality: swarm model economics.

Sonnet 5 executes. Fable 5 directs. That is Anthropic's recommended split for long coding and creative builds — not two sessions you switch manually, but one Claude Code session where Sonnet runs tools and Fable consults at decision points via the advisor tool.

The @ClaudeDevs July 8 benchmarks put numbers on it: ~92% of Fable solo on SWE-bench Pro at ~63% cost when Fable advises ~once per task. This guide is the how-to: /advisor setup, pairing rules, prompt templates (including a game-dev example), and when to use advisor vs opusplan vs subagents.

TL;DR — setup in 60 seconds

Official docs: Escalate hard decisions with the advisor tool · The advisor strategy · API advisor tool

Model pairing — what Anthropic allows

From the Claude Code advisor docs:

Your target pairing: Sonnet 5 main + Fable advisor — one of Anthropic's common pairings: "Fable 5 guidance at decision points without running Fable 5 throughout."

Subagents inherit the configured advisor if their model satisfies the pairing check.

Division of labor — executor vs advisor

Same framing as Matt Shumer's Workbench playbook: goal + bar for the project, execution for the fast model — except Anthropic wires Fable in as a server tool instead of you pasting advice manually.

Prompt principle: Tell Sonnet it is the implementation agent. Tell it to consult the advisor proactively — not only on errors, but on creative, architectural, pacing, progression, and UX decisions when multiple valid directions exist.

Prompt template — executor instructions

Paste this at the top of a long session (game, refactor, greenfield app):

You are the implementation agent (Sonnet 5).

## Your job
- Execute code, fix bugs, implement systems, ship working improvements.
- Do not stop to overthink — keep moving.
- Never ask me for implementation decisions unless truly blocked.

## Advisor (Fable 5)
Consult the advisor:
- Before any major feature or architecture change
- Before progression, boss, AI Director, UI redesign, or rendering systems
- Before marking a task complete (quality review)
- After 2+ failed attempts on the same issue
- Whenever multiple valid design directions exist — proactively, not only on errors

Flow: consult advisor → pick strongest solution → implement.

Advisor owns direction. You own execution.

Add project-specific tasks below (combat, weapons, story acts, etc.). Keep house rules and definition of done in the same doc — same pattern as Field Guide to Fable unhobbling: give Sonnet room to execute, fence with rules Fable helps refine.

Worked example — indie game AAA pass

A common failure mode: one giant prompt to Fable solo — expensive, or one giant prompt to Sonnet solo — shallow UI and weak systems design. Advisor split maps cleanly:

Delegate assets without blocking code: Sonnet keeps implementing with placeholders while image/audio agents run — same multi-agent pattern as loop engineering and official /loop guidance.

Story note: Acts (Escape → Mutation → Hunt) beat numbered levels. Advisor helps define narrative checkpoints; Sonnet wires when they trigger. Use image APIs at act boundaries — advisor drafts what each panel must communicate.

Enable advisor — three ways

1. /advisor command (recommended)

/model sonnet
/advisor fable

Saves to user advisorModel. If org availableModels blocks Fable, pick an allowed advisor or request access — see Fable 5 status.

2. settings.json

{
  "advisorModel": "fable"
}

3. Launch flag

claude --advisor fable

Session-only; overrides saved setting for that run.

Full command reference: Claude Code commands — /advisor.

When Claude calls the advisor

Anthropic docs: Claude decides when — tends toward:

1. Before committing to an approach
2. Recurring errors (same failure twice)
3. Before declaring done

You can force rhythm in prompts: consult the advisor before you continue — same as any tool request.

In session UI: Advising line with model name → Ctrl+O for full Fable guidance. Sonnet follows advice unless evidence contradicts it (file contents, failed step) — then it surfaces the conflict.

Cost: Advisor tokens bill at Fable rates; executor at Sonnet rates. Advisor runs at decision points, not every turn — see cost breakdown. Track with /usage.

Advisor vs opusplan vs subagents vs switching model

For month-long game polish: Sonnet + Fable advisor + subagents for assets beats Fable solo on cost and beats Sonnet solo on direction.

For API pipelines (not Claude Code), use advisor_20260301 — API setup in our orchestrator post.

Requirements checklist

• Claude Code v2.1.98+ (claude update)
• v2.1.170+ for Fable advisor
• Fable 5 access for your org/account
• Anthropic API billing or subscription — advisor not on Bedrock / GCP / Foundry
• Main model Sonnet 5 (or other compatible executor)
• Prompt tells Sonnet when to consult advisor proactively

Anti-patterns

Give the advisor a concrete decision, not the whole project again

A useful consultation names the decision, current evidence, constraints, and alternatives. For a game HUD, explain what players miss, show the relevant interface, and ask which change would improve readability without hiding combat. "Make it AAA" gives the advisor a quality aspiration but very little to judge.

Ask for tradeoffs and an acceptance check. If the advisor recommends larger cooldown indicators, the executor should implement that change and inspect whether it remains readable during the actual encounter. Advice is a proposal until the project supplies evidence that it solved the problem.

The official advisor guide is the authority for current pairing and access rules. The model names in a saved July example should not be treated as proof that your account currently exposes the same pairing.

Avoid paying for repeated consultations that lack new evidence

Before asking again about a failed approach, attach the error, relevant diff, or observed behavior. Repeating the same broad request can produce another plausible plan without resolving the missing information. The executor should first determine what changed since the previous advice.

Keep a short decision record: problem, recommendation, chosen approach, and result of the check. This avoids debating a settled decision later in the session and makes it clear when new evidence justifies reopening it. The record belongs in the project workflow, not only in the advisor's narrative.

For cost comparisons, include executor work, advisor calls, failed attempts, and verification. A lower bill on one completed benchmark task does not establish a universal savings percentage for your codebase. Judge the split by whether it reaches your acceptance criteria within the budget you set.

Consultation does not replace review

The executor remains responsible for checking files, running relevant validation, and reporting uncertain results. If the advisor suggests a change that conflicts with the code or task constraints, surface the conflict and inspect it before implementing. The stronger model's confidence is not a substitute for project evidence.

Finish a feature with the actual outcome: changed behavior, completed checks, and any remaining device or visual verification. That makes the advisor pattern a practical decision aid rather than another layer of persuasive completion claims.

Related on explainx.ai

• Claude zoom tool — Chartography Fable/Sonnet gains
• Claude Code desktop in-app browser — verify UI after advisor-planned redesigns
• Cursor agent swarm economics — planner/worker cost curves
• Fable 5 advisor & orchestrator patterns — @ClaudeDevs benchmarks
• Claude Code loops — official @ClaudeDevs guide
• Claude Code commands — /advisor, /model
• Field Guide to Fable — Thariq Shihipar
• Matt Shumer — goal/bar loops (GPT-5.6-Sol / Fable)
• Claude Code model vs effort
• Is Fable 5 back? — access hub
• Fable 5 top use cases July 2026

Official: Advisor tool — Claude Code docs · Advisor strategy blog · API advisor tool

Pairing rules, version gates, and availability reflect Anthropic's Claude Code documentation as of July 2026. Org allowlists and Fable access may limit /advisor fable on your account — verify with /advisor picker output.