Fable Advisor: a Claude Code plugin that turns Fable 5.1 into an architect and Codex into the typist

The problem Fable Advisor is built around

Most agent setups spend their most expensive tokens on the least interesting work. A single model reads the repository, plans the change, writes every line, and then grades its own output. The planning is where judgment matters. The typing is not. Fable Advisor splits those two jobs across model families: the session runs on Fable 5.1 as an architect that owns requirements, decomposition, specs and verification, while implementation goes to OpenAI Codex agents. The README frames it as "Fable 5.1 runs the show. Codex does the typing at the effort each task deserves, and Fable reviews before anything ships." The audience is Claude Code users on a Pro, Max, Team or Enterprise plan who also have access to the Codex CLI and want cross-vendor review without building the plumbing themselves. It is not a tool for someone who wants a single model to do everything.

How the architect pattern routes work between Fable and Codex

The mechanism leans on a Claude Code feature the README calls out directly: every subagent can run on a different model, and the session can run on a different model than its subagents. Fable Advisor exploits that with three lanes. Routine work goes to the `codex-implementer` agent, which drives GPT-5.6 Luna through the Codex CLI when the spec fully determines the outcome. High-complexity work goes to `sol-implementer`, running GPT-5.6 Sol, for cases where judgment the spec cannot capture decides the result: subtle concurrency, hard debugging, security-sensitive paths, wide refactors. The `fable-advisor` agent handles review at commitment boundaries and always once at the end, on a clean context, before the architect reports done.

Effort is not pinned. The architect writes `REASONING: low ... max` into the spec, with `ultra` available on Sol, and the lanes pass that value through unchanged. The session and the advisor run at whatever `/effort` you set. Model resolution in Claude Code follows a fixed order: the `CLAUDE_CODE_SUBAGENT_MODEL` environment variable, then a per-invocation `model` parameter, then agent frontmatter, then the session model. Effort resolves through `CLAUDE_CODE_EFFORT_LEVEL`, then agent frontmatter `effort`, then the session `/effort`. None of the plugin's agents set `effort`, so the advisor inherits your session setting while the Codex lanes take theirs from the spec. The README also notes a race option: for high-stakes work, run both implementation lanes on the same spec and let the architect pick the stronger diff.

Installing the plugin and running a first delegated task

Installation is two Claude Code plugin commands. The README gives them as a marketplace add followed by an install.

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

Updating an existing installation uses a marketplace update and a plugin update:

claude plugin marketplace update fable-advisor
claude plugin update fable-advisor@fable-advisor

Then start the session as the architect:

/model fable

Before any of this produces useful output, both implementation lanes need the OpenAI Codex CLI installed and authenticated. The README gives the sequence explicitly:

npm i -g @openai/codex
codex login

With that in place, you ask for work in plain language and the orchestration skill routes it. The README's own example is a rate-limiting change, which it flags as a concurrency-touching task suited to `sol-implementer` at `max`, or to racing both lanes. The architect writes the spec, picks the lane and effort, reads the diff and verification evidence when the report returns, sends the finished work to `fable-advisor`, and only then reports done. To make the doctrine always-on rather than per-prompt, the README says to add one line to your project's `CLAUDE.md`; the excerpt provided cuts off at the word "You", so the exact line is not something I can quote.

Advisor-only mode when you do not want the orchestration layer

The full pattern is optional. The README describes a lite mode it estimates at about 30 seconds: copy `agents/fable-advisor.md` into `~/.claude/agents/` and keep your session on Sonnet. You get advisor consults at commitment boundaries without the routing layer. This is the honest escape hatch in the design, and it also describes what happens by default when Codex is absent. Without the Codex CLI at all, the README states the pattern degrades to advisor-only mode. That is a reasonable failure posture: the plugin does not pretend to have a second vendor when it does not. The cost is that you lose the cross-vendor property that makes the review worth reading. A Fable advisor reviewing Fable-authored plans is a weaker signal than a Fable advisor reviewing a diff written by a different model family, and the README is explicit that the cross-vendor review is built into the routing rather than bolted on.

Where Fable Advisor breaks, degrades or reports unavailable

The failure modes are documented, which is better than most plugins manage, but two of them are quiet. The loud one is the Codex lane: without model access, an installed and authenticated CLI, or successful authentication, a lane reports `STATUS: unavailable` and never silently falls back to a Claude model. That is the behaviour you want. The quiet one concerns Claude model pins. The README warns that if a pinned Claude model is not available on your account, Claude Code silently falls back to your session model, so the pattern degrades quietly rather than erroring. The README's own diagnostic advice is blunt: if advisor verdicts feel unremarkable, check your plan. Model access is the second constraint. The README notes that GPT-5.6 access may be limited during preview, so a lane can be correctly configured and still unavailable through no fault of your setup.

The wrong-tool case is a small codebase with a single obvious change. Writing a six-part spec, selecting a lane, choosing an effort rung and booking a clean-context review costs more than the edit. The README's own routing table sends routine work to the cheap lane precisely because the spec determines the outcome; if you cannot state the outcome in a spec, you are paying orchestration overhead for a task that never needed it. Cost discipline is part of the shipped skill, described as emitting judgment rather than volume and keeping context lean, but that discipline depends on you writing specs that are actually complete.

How this differs from running Codex inside Claude Code directly

The closest alternative is the official Codex plugin for Claude Code, and Fable Advisor treats it as complementary rather than competing. The README lists it as optional: when enabled, the orchestration skill uses `/codex:adversarial-review` as a GPT-family second reviewer ahead of the Fable review, `/codex:rescue` as a user-driven delegation path, and `/codex:setup` to diagnose a lane reporting `unavailable`. The difference in approach is who decides. The Codex plugin gives you commands you invoke; Fable Advisor adds a routing doctrine that decides which lane and which effort a task deserves, and a spec contract that makes context-free delegation safe. It also drives `codex exec` directly either way, so the Codex plugin is not a dependency. If you want a second model on demand and no opinion about when to use it, the Codex plugin alone is less machinery. If the problem you have is inconsistent delegation, the doctrine is the product.

Maintenance, licensing and what an upgrade costs you

The repository is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. I am not giving legal advice; read the LICENSE file at the repository root before redistributing. The last push to the default branch was on 2026-09-02, and v5.0.0 was released the same day, so the project is current as of that date rather than abandoned. The top-level layout is small: `.claude-plugin/`, `agents/`, `skills/`, `assets/`, `LICENSE`, `README.md`. That shape matters for upgrade cost. The plugin ships an orchestration skill that encodes routing doctrine, and the README describes that skill as teaching the session when to use each lane and effort rung. Doctrine changes between releases, so an upgrade can change how work is routed even when no command changes. The install and update commands are two lines each, and the lite mode is a file copy, so the mechanical cost is low. The real cost is re-reading the routing table after a major version bump and confirming your `CLAUDE.md` line still matches the doctrine the new release ships.

Editorial conclusion

Adopt Fable Advisor if you already pay for a Claude plan that includes Fable 5.1, you are willing to install and authenticate the OpenAI Codex CLI, and your work decomposes into specs that a different model family can implement without your context. Do not adopt it if you want one vendor, one bill, or a plugin that fails loudly when a model pin is missing: the README states that an unavailable Claude model pin falls back silently to the session model, so a degraded setup can look like a working one. Before trusting it, verify three things in your own environment: that `codex login` succeeds and both lanes return real output rather than `STATUS: unavailable`, that `/model fable` actually resolves on your plan, and that the six-part spec contract in the orchestration skill is one your team will actually write, because the whole pattern rests on delegation to a model that never sees your conversation.

Frequently asked questions

Official sources

1. DannyMac180/fable-advisor on GitHub
2. Issues
3. License: MIT
4. README
5. Releases