Fable Orchestrator: A Codex Routing Skill Where Fable 5.1 Plans and Luna or Flash Implements

The problem Fable orchestrator targets: planning that leaks into execution

Most agent setups let the same model plan the work and then write the code. Fable orchestrator takes the opposite position. The README states that Fable 5.1 "plans and adjudicates; it does not write code or own the workspace." Codex stays the runtime, and implementation is delegated to OpenCode Go agents: GPT-5.6 Luna for normal implementation, DeepSeek V4 Flash for loops, repeated iteration and high-throughput work. Fable 5.1 sits outside the implementation graph. That separation is the whole product. It is aimed at engineers who already use Codex and Codex Router and who want the planning model to hold no write access to the workspace. If you are not in that setup, the skill has nothing to attach to: it consumes the callable opencode-go/ and opencode-go-responses/ agents supplied by Codex Router, and it ships no proxy, dashboard, model catalog, credential store or API key of its own.

How the routing graph moves from objective to verified result

The flow starts when you invoke the skill with an objective. Fable returns a bounded graph. Codex validates that graph, starts ready workers in parallel when useful, collects their evidence, and verifies the result. When the task needs another decision, Codex asks Fable to adjudicate. Every implementation node must use GPT-5.6 Luna or DeepSeek V4 Flash. That constraint is enforced at the graph level rather than left to the model's judgement, and the README is explicit about the failure path: if neither allowed OpenCode Go route is callable, the workflow reports the blocker instead of inventing a model. The packet sent to Fable carries decisions and workspace facts only, and the README warns never to put credentials in a packet. The repository layout is small enough to read in one sitting: skill/fable/ contains SKILL.md, agents/openai.yaml and scripts/ask_fable.sh, and those three files are the installable skill. ask_fable.sh is executable and invokes Claude Code's local fable alias with no session persistence, which means each adjudication is a fresh call rather than a continuing conversation.

Installing the skill and running a first objective

The installer is a shell script at the repository root. Run it first in dry-run mode, which prints the exact destination and copy operations without creating files:

./install.sh --dry-run

If the printed destination looks right, copy mode installs to ~/.codex/skills/fable, creates only the required directories, and is safe to run again:

./install.sh --copy

To install somewhere else, pass --target with a directory. The README gives this example:

./install.sh --copy --target "$PWD/.local/codex/skills"

The installer reads only this repository and the destination path. It never reads, creates or modifies credentials. After changing the provider or agent definitions, start a new Codex task. To use the skill, invoke it with an objective:

$fable build the feature

What you should see is a returned graph rather than a diff: Codex validates it, runs the ready workers, collects evidence and verifies. The repository also ships dependency-light checks that you can run before trusting the install:

tests/test_skill.sh

According to the README, that test checks shell syntax, the copied source files, required routing strings, basic YAML structure, optional xmllint XML validation, SVG safety constraints, a temporary-home dry run, an idempotent copy, and common credential-shaped strings. It does not require PyYAML or a live Claude login.

Where the design constrains you

The most consequential limitation is the dependency on Codex Router. The README says to configure OpenCode Go once in the router, then restart Codex after changing provider or agent definitions. Fable orchestrator does not manage those definitions for you, and it does not ship a credential store, so any authentication problem lives in the router, not here. The second constraint is model choice. Because every implementation node must use GPT-5.6 Luna or DeepSeek V4 Flash, the skill is the wrong tool when your work needs a model outside those two routes; the workflow will report a blocker rather than route around it. That is a deliberate safety property, but it also means the skill cannot be a general-purpose fallback. Third, ask_fable.sh runs with no session persistence, so adjudication calls do not accumulate context between invocations. If your task depends on a long-running conversation with the planner, this is the wrong shape. Finally, the README does not document rollback or uninstall, so plan the target directory before you run --copy rather than after.

How this differs from a single-model agent loop

The obvious alternative is letting one capable model plan and implement in the same session, which is how most Codex and Claude Code workflows operate by default. The difference is not capability but blast radius. In a single-model loop, the planning call and the writing call share the same context and the same workspace authority. Here, Fable 5.1 returns a graph and Codex owns execution, validation and verification. A related alternative is a general router that exposes many models behind one endpoint: Fable orchestrator is not that either, since it consumes two named OpenCode Go agents and refuses to invent a model when neither is callable. If you want breadth of model choice, a router alone serves you better. If you want the planner kept out of the implementation graph, the split here is the point.

Maintenance, licence and what the repository commits to

The last push was on 2026-09-04, and the repository is not archived. The project is MIT licensed, which permits commercial and private use, modification and redistribution provided the licence and copyright notice are retained; this is a description of the licence terms, not legal advice, and you should read LICENSE in the repository for the operative text. The maintenance surface is unusually small: one installer, three skill files, one test script and one SVG asset. That cuts upgrade cost, because there is no proxy, dashboard or model catalog to keep in sync with upstream providers. It also means the project's health tracks Codex Router and the OpenCode Go agent definitions rather than anything inside this repository. If those upstream agent names change, the routing strings checked by tests/test_skill.sh are where the breakage will surface first.

Editorial conclusion

Adopt fable-orchestrator if you already run Codex with Codex Router and want planning kept outside the implementation graph; skip it if you need a shipped proxy, dashboard or credential store, because it provides none. Before relying on it, run tests/test_skill.sh and confirm both opencode-go/ and opencode-go-responses/ routes are callable, since the workflow reports a blocker rather than substituting a model when neither allowed route responds.

Frequently asked questions

Official sources

1. codejunkie99/fable-orchestrator on GitHub
2. Issues
3. License: MIT
4. README