fable-the-boss

Your agent as the boss. Codex, Cursor, and any headless coding agent as the crew.

The pattern, straight from Anthropic

Anthropic's developer team shared the multi-agent patterns they use internally with Claude Fable 5. The one this skill builds on is the orchestrator: Fable 5 plans and delegates to cheaper workers, so most tokens are billed at the worker rate — 96% of Fable-solo performance at 46% of the cost on BrowseComp.

Diagram by Anthropic, from the @ClaudeDevs thread.

The economics work because orchestration is mostly decision-making in underdetermined spaces — vague reports, partial evidence, judgment calls with no spec — which is exactly what Fable 5 is unusually good at, and exactly what the cheap majority of tokens doesn't need.

This skill: the orchestrator pattern, across harnesses

fable-the-boss reconstructs the orchestrator pattern as an agent skill — with the crew drawn from other vendors' harnesses instead of cheaper Claude models. The boss (your agent) composes self-contained task prompts and dispatches them to long-lived worker sessions of other harnesses — OpenAI Codex CLI and Cursor Agent ship as built-in references (codex exec resume, cursor-agent --resume), and any harness with a resumable headless CLI can join the crew — running as true background processes. The economics get more aggressive than the original: worker tokens are billed to each harness's own subscription, and the boss burns exactly zero tokens while waiting.

Delegation is not fire-and-forget: a worker may stop mid-task and report what advice it needs (the NEED_ADVICE: protocol); the boss answers — escalating to you only what is genuinely yours to decide — and resumes the same session.

Where the official pattern pairs Claude models on both sides, this skill only asks that the boss's harness can wake on background-task completion — the crew can come from any vendor, and you get to spend all your separate quotas in one place.

How it works

One task, end to end:

sequenceDiagram
    actor U as You
    participant B as Boss (orchestrator)
    participant G as Git worktree
    participant W as Worker (codex / cursor)
    U->>B: "have codex fix the retry logic"
    B->>G: cut worktree from current HEAD
    B->>W: dispatch prompt (background, resume session)
    Note over B: end turn — zero cost while waiting
    W->>G: edit, run tests, commit
    W-->>B: process exits → wake notification
    B->>B: read report + diff --stat (facts, not code)
    B->>U: relay report + change footprint
    U->>B: accept / iterate / discard
    B->>G: merge or drop, destroy worktree

Three design principles:

Session and workspace are decoupled. A worker's session (its memory) is long-lived. Its workspace is a disposable git worktree created per task from the boss's current HEAD, and destroyed once the result is merged or discarded. Work is always based on the latest codebase by construction — there is no sync step to forget.
The boss stays at the reporting surface. On wake it reads the worker's final report, the exit code, and git diff --stat — not the code. The worker's own verification (tests, builds) backs quality; the boss does fact-checking (does the report match the observable footprint?), and code review happens only when you ask for it.
Guarded autonomy, bounded blast radius. Workers run at the strongest reviewed tier their harness offers headless (cursor: --auto-review, a classifier auto-runs safe calls and holds the rest; codex: full access for now, since headless codex exec has no approval channel — a per-call approval broker is tracked in issue #1). The disposable worktree bounds the blast radius in every case; your main working tree is never touched.

Install

Via skills.sh (installs into Claude Code, Codex, and other Agent-Skills-standard harnesses):

npx skills@latest add tuoxiansp/fable-the-boss

Or let your agent install it — paste this:

Install the "crew" agent skill from https://github.com/tuoxiansp/fable-the-boss
(it lives at skills/crew in that repo).

Use

/crew takes free-form natural language. Build the crew (per project; the registry lives in .claude/crews.json):

/crew take codex onto the crew
/crew register cursor as a worker, use gpt-5.2
/crew add my existing codex session abc123 as a reviewer
/crew who's on the crew?

On first registration the boss agrees a model baseline with you — which model per harness, and what kind of work suits it — stored in the registry's $policy key so later decisions don't need to re-ask.

Then just work. The boss delegates on its own judgment: give it a goal, and it decides what to hand to the crew and what to do itself, announcing each dispatch in one line. It also provisions new workers (using the $policy baseline) when the work calls for a parallel lane. You can still direct traffic whenever you want:

/crew have codex implement the retry logic in src/net/, run the tests, and commit

— or veto a delegation mid-conversation ("do this one yourself").

For each dispatched task the boss cuts a worktree, dispatches in the background, and yields. When the worker finishes you get the report and rule on it: accept (merge), iterate (same session, corrective feedback), or discard. Either way the worktree is destroyed.

[!TIP] While the boss drives a worker session, that harness's own UI may not show live updates: headless turns typically open with one short message and then work silently through tool calls, so an app or TUI open on the same session can look stalled while the worker is in fact deep in a task. Follow progress through the boss's reports (or tail the dispatch's output stream) — and avoid driving the same session from two places at once; session histories assume a single writer.

Live console

Dispatches are silent by design — so the skill ships a local web console to watch the whole crew, across all your projects, in one page. Every dispatch runs one idempotent command (crew-console watch <project>) that enrolls the project and auto-starts the console daemon if needed; open http://127.0.0.1:7317/ to see each worker's phase, current activity, and recent events, updating live.

How a worker is observed is a per-harness provider (console/providers/). Built-ins cover codex (dispatch stream, falling back to its session files — so even externally driven sessions are visible) and cursor; a project can override or add providers in .claude/crew-providers/, and your agent can write one when adopting a new harness.

Is your harness boss material?

The boss side needs exactly one capability: start a process in the background, end the turn, and get woken when the process exits. Paste this probe into your agent to find out (it is the exact prompt that bootstrapped this project):

This is a harness capability test. Follow these steps EXACTLY. Do not improvise.

1. Print the current time with `date +%T`.
2. Start this command as a TRUE BACKGROUND task (do NOT run it as a normal
   blocking/foreground tool call):
   sh -c 'sleep 180; date +%T > /tmp/harness-wake-test.txt; echo WAKE_SENTINEL'
   If your environment has a dedicated way to run a command in the background
   (a background flag, a task/job tool, etc.), use it. If you have NO way to
   run a command without blocking on it, say exactly "NO_BACKGROUND_SUPPORT"
   and stop.
3. After starting it, END YOUR TURN IMMEDIATELY. Your last message must be
   exactly: "STARTED_AND_YIELDING".
   - Do NOT wait for the command.
   - Do NOT sleep, poll, re-check, or read the output file.
   - Do NOT call any more tools this turn.
4. ONLY IF something wakes you up later (a notification, an injected message,
   a tool event), reply with:
   - the word "WOKEN_BY_HARNESS"
   - the current time from `date +%T`
   - the raw content of whatever woke you, quoted verbatim
   - the content of /tmp/harness-wake-test.txt

Never simulate step 4. If nothing ever wakes you, stay silent forever.

If you get STARTED_AND_YIELDING, then ~3 minutes of silence, then WOKEN_BY_HARNESS with a timestamp ~180s after the first one — your harness can be the boss. If the agent blocks on the command, answers immediately, or never comes back, it can still be a fine worker, just not the boss.

The name

A nod to Claude Fable 5 — the model whose orchestrator pattern this skill reconstructs, the first model to boss this particular crew around, and the recommended boss. The skill itself is model-agnostic.

License

MIT

Fable The Boss

At a glance

README