A Fable of Codexes

Claude Code skills that make Claude (Fable, or Opus when Fable is unavailable)
the conductor of an AI worker fleet. The conductor surveys and plans,
dispatches many parallel OpenAI Codex CLI workers for implementation and
Claude Opus agents for design judgment, then integrates, reviews, and verifies
what comes back.

One session directs the whole effort: workers spend their own context on
implementation while the conductor's stays free for judgment, git worktrees
let many writers land in parallel without collisions, and campaign state
lives in the repo so any later session resumes mid-campaign without setup.

Skills

campaign-conductor

Runs a project as an orchestrated campaign.

• Bootstrap. First use in a repo copies templates from
  assets/campaign-hq/ into docs/campaign-hq/: CAMPAIGN.md for the plan
  and fleet table, LEARNINGS.md for distilled lessons, preferences.md for
  worker routing, and schemas/worker-result.json for reports. It also adds a
  pointer to the project's CLAUDE.md so later sessions resume from repo state.
• Routing. Fable/Opus stays on planning, judgment, verification, and memory.
  Codex CLI handles implementation, tests, research, and mechanical refactors
  when available. Claude worker agents use the same briefs and reports when
  Codex is unavailable or exhausted. Live worker, model, and effort requests win
  over defaults, are written to preferences.md, and persist across sessions.
• Campaign sizing. Small projects get a directly written plan. Large or
  unfamiliar ones get a parallel survey fan-out that drafts the plan for
  sign-off first.
• Parallel fleets. One writer per tree: git worktree and branch per
  worker, a fleet table tracking every dispatch with its session id,
  integration handled as its own dispatched task, and big campaigns
  structured as waves: dispatch, collect, integrate, verify. Finished Codex
  sessions resume with context intact for incremental corrections.
• Squads. For cohesive sub-goals, a Claude squad lead dispatches its own
  Codex workers, integrates, verifies, and returns one branch, with a hard
  depth cap, an exclusive branch namespace, and per-leaf evidence required
  in its report.
• Review gates. Fixed-schema worker reports, cross-model review (Claude
  reviews Codex diffs and Codex reviews Claude's), and same-brief bake-offs
  judged on artifacts for high-stakes tasks.
• Worker capabilities. Doctrine covers Codex web search for research
  scouts, image input for UI fixes from screenshots, native image generation
  for assets, and review mode.
• Permissions. The worker power envelope is set once at kickoff and
  recorded (Codex sandbox level, network access, Claude permission mode), so
  no wave stalls on a mid-run prompt.
• Compounding memory. Every dispatch outcome and user correction is
  logged, then compacted into standing rules so the files stay cheap to read
  at session start.
• Progressive disclosure. The main SKILL.md is a short conductor checklist.
  Detailed Codex dispatch, worktree/wave operations, squads, and review gates
  live in references/ and load only when needed.

examples/campaign-hq/ shows the state files
mid-campaign, including a worked worker brief and the report schema.

Orchestration patterns

The panels are worked examples. Any capable worker can lead, integrate, or
review, and a campaign composes whatever shape the work needs.

Squads nest the fan-out: a squad lead (Opus or Codex) dispatches its own
parallel workers, integrates their branches, and hands the conductor one
verified branch. Tested end to end both ways: a spawned Opus lead ran Codex
workers in parallel worktrees, each landing its own commit, and a Codex lead
fanned out its native subagents inside one workspace.

flowchart TD
    C[Fable conductor] -->|sub-goal briefs| S1[Squad lead · Opus]
    C --> S2[Squad lead · Codex]
    S1 --> A1[Codex] & A2[Codex] & A3[Codex]
    S2 --> B1[Codex] & B2[Codex] & B3[Codex]
    A1 & A2 & A3 --> I1[campaign/search<br>integration branch]
    B1 & B2 & B3 --> I2[campaign/billing<br>integration branch]
    I1 --> V[Conductor merges,<br>re-verifies]
    I2 --> V
    V --> M[(main)]

Campaign state lives in the project, so any later session resumes it:

docs/campaign-hq/
├── CAMPAIGN.md      plan, phases, fleet table
├── LEARNINGS.md     standing rules + dispatch log
├── preferences.md   worker routing, permission envelope
├── briefs/          one file per dispatch
├── out/             collected worker reports
└── schemas/         worker-result.json

Install

npx skills add jvogan/a-fable-of-codexes --skill campaign-conductor

or manually:

git clone --depth 1 https://github.com/jvogan/a-fable-of-codexes.git /tmp/afoc
cp -r /tmp/afoc/skills/campaign-conductor ~/.claude/skills/

Use

Install the skill, then say in any project:

start a campaign

Claude bootstraps docs/campaign-hq/, sizes the plan to the project, and
begins dispatching workers. From then on, every session in that repo picks up
the campaign automatically. Direct it in plain language:

• "add a phase for the billing migration"
• "use sonnet for tests from now on" (persists in preferences.md)
• "status" (reads the plan and fleet table)

Requirements

• Claude Code. The skill uses the Agent and Workflow tools.

• OpenAI Codex CLI (github.com/openai/codex).
  Install with npm install -g @openai/codex (or brew install codex), then
  run codex login. ChatGPT-plan auth consumes plan usage and limits vary by
  plan; API-key auth is token-priced. Size worker waves to your available
  limits and spend tolerance. Set the default worker model and reasoning
  effort in ~/.codex/config.toml, for example:

  model = "gpt-5.6-sol"
  model_reasoning_effort = "high"
  

  Reasoning runs a ladder (low, medium, high, xhigh, max, ultra),
  and the model ships in frontier, balanced, and fast variants. high on the
  frontier model is a sound default; reserve max/ultra for the hardest
  architecture and debugging. Override per task in plain language ("use ultra
  Codex for this wave", "send the mechanical refactor to the fast model"): the
  conductor writes the request to preferences.md, where it persists.

  Without Codex installed, the skill runs Claude-only fleets: Sonnet workers
  take the implementation role, Opus keeps design and squad-lead duty, and
  the briefs, worktrees, squads, and reports stay the same.

• Codex plugin for Claude Code (optional,
  github.com/openai/codex-plugin-cc).
  Adds /codex:review, /codex:adversarial-review, and background-delegation
  slash commands for single interactive tasks. Install inside Claude Code:

  /plugin marketplace add openai/codex-plugin-cc
  /plugin install codex@openai-codex
  

Validation

python3 scripts/validate.py
npx --yes skills add . --list

Checks every skill against the
Agent Skills spec: frontmatter
fields, name format, and description length, plus this repo's 500-line body
limit and relative-link integrity. The skills command verifies that the
package is discoverable by the installer. CI runs both commands on every push
and pull request.

License

MIT