fable-advisor

Fable Advisor

The smartest model runs the show. Cheaper models do the typing.

Claude Code lets every subagent run on a different model — and lets the session itself run on a different model than its subagents. This plugin exploits that with the architect pattern: your session runs on Fable 5, Anthropic's most capable model, acting as a full-time architect. It owns requirements, decomposition, specs, and verification — and routes every implementation task to the cheapest adequate lane:

Lane	Producer	Invocation	Route here when
Routine	Grok 4.5	grok-implementer agent (default)	The spec fully determines the outcome — Grok does the typing via the Grok CLI
Cross-vendor	GPT-5.5	codex-implementer agent	Correctness-critical, or you want a second independent implementation to compare
Judgment	Fable 5	fable-advisor agent	Commitment boundaries — see below

Tokens route by volume: the expensive model emits the fewest tokens (judgment and specs), cheap lanes emit the most (code). Implementation mechanics are ~90% of a session's tokens and Grok 4.5 handles them at near-parity — so this runs far cheaper than Fable-for-everything, and every implementation comes from a different model family than the architect that reviews it: cross-vendor review is built into the routing, not bolted on. For high-stakes work, race grok-implementer and codex-implementer on the same spec and let the architect pick the stronger diff.

The plugin ships the orchestration skill — the routing doctrine that teaches the session when to use each lane, the cost discipline that keeps the expensive model's own token volume minimal (emit judgment not volume, keep context lean, reason once then hand off), the five-part spec contract that makes context-free delegation safe, and the verification rules that keep cheap lanes honest.

Install

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

Then start your session as the architect:

/model fable

Lite mode — one file, 30 seconds. Don't want the full pattern? Copy agents/fable-advisor.md into ~/.claude/agents/ and keep your session on Sonnet. You get advisor consults at commitment boundaries without the orchestration layer (see "Advisor-only mode" below).

Requirements

• Claude Code ≥ 2.1.170 with a subscription that includes Fable 5 (Pro, Max, Team, or Enterprise — all current consumer plans qualify).
• No Fable access (e.g. API-key billing)? Use /model opus for the session and change model: fable → model: opus in the advisor file. Same pattern, model tiers shift down one.
• Grok lane (the default implementer): the grok-implementer agent needs the xAI Grok CLI installed and authenticated (install from x.ai/cli, then grok login). It drives Grok 4.5 headlessly (grok --prompt-file … -m grok-4.5). Without it the agent reports STATUS: unavailable — it never silently falls back to a Claude model.
• Codex lane (optional): the codex-implementer agent needs the OpenAI Codex CLI installed and authenticated (npm i -g @openai/codex, then codex login). Without it the agent reports STATUS: unavailable — the other lanes are unaffected.
• Heads-up: if a pinned Claude model isn't available on your account, Claude Code silently falls back to your session model — the pattern degrades quietly rather than erroring. If results feel unremarkable, check your plan. (This quiet fallback applies only to Claude model pins — the grok and codex lanes always fail loudly with a structured error.)

Model resolution order in Claude Code: CLAUDE_CODE_SUBAGENT_MODEL env var → per-invocation model parameter → agent frontmatter → session model.

Use it

With the session on Fable, just ask for work — the orchestration skill routes it:

Add rate limiting to our public API. Design it, delegate the
implementation, and verify the evidence before you call it done.

The architect writes the spec, picks the lane (rate limiting touches concurrency — a good case for racing grok-implementer against codex-implementer and picking the stronger diff), reads the diff and verification evidence when the report comes back, and only then reports done.

To make the doctrine always-on, add one line to your project's CLAUDE.md:

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.

Commitment boundaries