Fable Advisor Complete Guide — Master Claude Code Model Routing to Cut Costs by 60%

"The smartest model designs, the cheap model implements." Fable Advisor is a Claude Code plugin that realizes this simple architecture pattern, fully leveraging Claude Code 2.1.170+'s ability to specify different models for sessions and subagents.

What You'll Learn

What Fable Advisor is and why it matters
How to use the 4 lanes
Installation steps and requirements
Real usage (from basic requests to advanced)
How to write specs (Spec Contract)
Verification rules and commitment boundaries

What Is Fable Advisor?

Fable Advisor is a Claude Code plugin developed by DannyMac180. The underlying idea is simple:

90% of tokens are implementation mechanics (writing code, running tests, reading files) — using a high-performance model like Fable 5 there is wasteful. Design, judgment, and verification genuinely need Fable 5's capability.

So Fable Advisor completely separates the roles:

Lane	Role	Model	Scope
Design	Architect	Fable 5	Requirements, design, specs, routing, verification
Implement	Implementer	Sonnet (standard) / Opus (advanced)	Coding, test execution, file operations
Codex	Alternate implementer	GPT-5.5	Correctness-critical implementation, vendor diversity
Advisor	Second opinion	Fable 5	Design decision validation, risk assessment

Cost Impact

Fable 5 costs about 3× Sonnet's per-token price. But roughly 90% of total token consumption is implementation mechanics, where Sonnet suffices. Applying the Fable Advisor pattern:

Approach	Quality	Cost (vs Sonnet)
All Fable 5	Highest	3.0×
All Sonnet	Sufficient	1.0×
Fable Advisor	Highest	~1.4×

The biggest value: cut costs roughly in half without sacrificing quality.

Installation

Full Plugin (Recommended)

Just run these two commands in the terminal:

claude plugin marketplace add DannyMac180/fable-advisor
claude plugin install fable-advisor

Switch to architect mode when starting a session:

/model fable

Lite Mode (Done in 30 Seconds)

If you don't need the full orchestration pattern, copy agents/fable-advisor.md to ~/.claude/agents/ and you get the advisor-only functionality. Keep the session on Sonnet, consulting Fable 5 only at commitment boundaries.

Requirements

Item	Condition
Claude Code	Version 2.1.170+ (Pro / Max / Team / Enterprise subscription)
If Fable 5 unavailable	Run the session with /model opus and change model: fable to model: opus in the advisor file
Codex lane (optional)	Requires npm i -g @openai/codex and codex login. Other lanes work fine without it

Note: If the model specified in your account isn't available, Claude Code silently falls back to the session model. If you don't see the effect, check your plan.

Using the 4 Lanes

The core of Fable Advisor is "which task routes to which lane." That determines efficiency.

Lane 1: Routine (Sonnet) — the default lane

How to invoke: implementer agent (default)

Use this lane when:
  Specs fully determine the outcome
  Boilerplate, wiring, CRUD
  Mechanical edits, simple feature additions

When in doubt, use this lane.

Lane 2: Advanced Implementation (Opus) — when Sonnet mistakes are expensive

How to invoke: specify model="opus" on the implementer agent

Use this lane when:
  Concurrency- or security-related code
  Hard debugging, wide-impact refactoring

Criterion: "work where a Sonnet mistake costs more to fix"

Lane 3: Alternate Implementation (GPT-5.5 / Codex) — for vendor diversity

How to invoke: codex-implementer agent

Use this lane when:
  Correctness is an absolute requirement
  You want to avoid blind spots of the same model family
  You want to implement with both Claude and GPT-5.5 and pick the better one (race)

Prerequisite: codex CLI installed and authenticated

The distinction from Opus is not capability, but failure distribution. Opus offers higher capability within the same model family; Codex covers blind spots of a different family.

Lane 4: Judgment (Fable 5 / Advisor) — read-only second opinion

How to invoke: fable-advisor agent

This is not an implementation lane.
It writes no code — it only validates design decisions.

When to use it is detailed in the "Commitment Boundaries" section below.

Commitment Boundaries

This is the most important concept. The habit of always calling the advisor right before "making a decision" determines quality.

When to call the advisor:
  1. Before architecture decisions
  2. Before data migrations
  3. Before large refactors
  4. Before finalizing API design
  5. When the same bug wasn't fixed twice
  6. Before declaring multi-file deliverables "done"

The advisor returns a verdict in 300 words or less. It actually reads the codebase and judges with fresh eyes, unswayed by the current session's context.

Real Usage

Basic: Just ask for the task

Start the session with Fable 5 and make a normal request:

/public APIにレート制限を追加したい。
設計して、実装を委譲して、証拠を確認してから完了と言って。

The architect (Fable 5) automatically runs this flow:

1. Break down requirements → create a spec
2. Select the optimal lane (concurrency involved → Opus lane)
3. Delegate implementation → review the diff
4. Run verification commands → report done only after passing

Apply Permanently via CLAUDE.md

Add this to your project's CLAUDE.md to enable the architect pattern in every session:

You are the architect running the most expensive model — minimize your own token volume.
Delegate all implementation through the orchestration skill's routing table (never type code yourself),
delegate broad codebase exploration to cheap read-only agents, and verify evidence before accepting any lane's report.

Advisor-Only Operation (Inverse Pattern)

Keep the session on Sonnet and consult fable-advisor only at commitment boundaries:

新しい決済システムの設計をしたい。
計画を立てて、コミットする前にアドバイザーに相談してから実装して。

Add this to CLAUDE.md to have the advisor auto-check:

Before committing to any architecture decision, migration, or refactor touching 3+ files,
consult the fable-advisor agent and act on its verdict.

The 5 Elements of a Spec (Spec Contract)

When delegating a task to an implementer, always fully include these 5 elements:

#	Element	Example
1	Objective	"Create a user profile edit feature" → in one paragraph
2	Files	src/app/profile/edit.tsx, src/lib/profile.ts
3	Interfaces	Signatures, types, and API shapes the code must conform to
4	Constraints	Project conventions, files not to touch
5	Verification	Commands that prove correctness, e.g. npm run test:profile

If you can't finish writing the spec, you haven't finished deciding. Don't dump ambiguity onto a cheap model. If the spec has gaps, instruct the implementer to "report the gaps."

Verification Rules

"A report is not evidence" — this is the iron rule.

Never take an implementer's report at face value. Always:

Read the diff (git diff / git status)
Re-run verification commands yourself

"It should work" or "tests should pass" is the same as not done. Reject reports without actual verification output. If errors appear, write the correct spec and re-delegate (don't fix it yourself).

Practical Workflow Examples

New Feature (Routine Lane)

You: "Build a profile edit feature"

Architect's actions:
  1. Break down requirements
  2. Create a spec (5 elements)
  3. Delegate to the routine lane (Sonnet)
  4. Review diff + run tests + pass → report

Adding Concurrency (Opus Lane)

You: "Change the WebSocket connection to concurrent processing"

Architect's actions:
  1. Design decision → commitment boundary → consult fable-advisor
  2. Advisor: "Safe, but mind the disconnect handling" → reflect in design
  3. Delegate to the Opus lane
  4. Review diff + run load tests + pass → report

Mission-Critical Implementation (Codex Race)

You: "Build a new payment microservice"

Architect's actions:
  1. Architecture design → consult fable-advisor
  2. Create the spec
  3. In parallel: delegate the same spec to Sonnet + GPT-5.5
  4. Compare both diffs → adopt the better one
  5. Re-run verification commands → report done

Architect Cost Discipline

The designer (Fable 5) itself is also a cost-optimization target. Follow these 3 principles:

Output decisions, not volume Fable 5 doesn't write code. Implementation code, test bodies, and boilerplate all go to cheap lanes.
Keep context thin Don't paste entire files or long diffs into conversation. Path references and excerpts are enough. Let cheap read-only agents do browsing.
Delegate immediately after thinking once Finish design decisions in one pass, seal them into the spec, and delegate. Rethinking repeatedly is expensive.

FAQ

Is this the same as Anthropic's "advisor tool"? No. That's a server-side API feature. Fable Advisor is built from regular Claude Code subagents + a skill — fully readable and editable, no beta flag needed.

Does it work on claude.ai (web)? No. Subagent model routing is Claude Code-only (CLI, desktop, VS Code, and web Claude Code).

Why not just use Fable 5 for everything? Fable 5 is indeed the highest quality. But it costs 3× Sonnet per token, and 90% of tokens are implementation mechanics. Use the premium only where judgment matters.

Why is there a GPT-5.5 lane in a Claude plugin? For vendor diversity. Same-model families share blind spots. Building an independent implementation in a different family covers misses in both directions.

Does upgrading from v1 change anything? Nothing breaks. The fable-advisor and implementer agents are the same as v1. v2 adds the orchestration skill and the Codex lane.

Is it okay if the Codex lane isn't available? Yes. codex-implementer just returns STATUS: unavailable; the other three lanes work completely normally.

Reference Links

GitHub: GitHub - DannyMac180/fable-advisor
Claude Code docs: Anthropic Claude Code official docs
Fable 5 prompting guide: Anthropic Fable 5 prompting guide

Adoption Checklist

[ ] Check Claude Code version (claude --version → 2.1.170+)
[ ] claude plugin marketplace add DannyMac180/fable-advisor
[ ] claude plugin install fable-advisor
[ ] Start session with /model fable
[ ] Request your first task and verify it works
[ ] Add the always-on CLAUDE.md config (optional)
[ ] Enable the Codex lane (optional): npm i -g @openai/codex && codex login

Published: 2026-07-07 | Category: AI Tools Source repo: DannyMac180/fable-advisor (MIT License)