A Fable of Codexes Complete Guide 2026 — How to Build an AI Worker Army Led by Claude

Claude becomes the "conductor" and runs multiple Codex CLI workers simultaneously to push projects forward at once — this is "A Fable of Codexes."

If Fable Advisor (covered in the previous article) is about lane separation where "a smart model designs and a cheaper model implements," this one is more like "one conductor directing ten craftsmen simultaneously." It's a full-scale orchestration skill that includes parallel processing, conflict prevention via git worktree, and campaign management.

What You'll Learn in This Article

What A Fable of Codexes is (and how it differs from Fable Advisor)
Installation steps (detailed for beginners)
Actual usage and workflow
How to manage campaign progress
Full overview of parallel workers, squads, and reviews

What Is A Fable of Codexes?

"A Fable of Codexes" is a Claude Code skill developed by jvogan. The concept is simple:

Make Claude (Fable or Opus) the "conductor" and run multiple Codex CLI workers simultaneously for parallel project development.

Differences from Fable Advisor

Comparison	Fable Advisor	A Fable of Codexes
Architecture	Claude Code sub-agent feature	Launches Codex CLI as external workers
Parallelism	Delegates one task at a time	Runs many workers in parallel simultaneously
Conflict prevention	Automatic sub-agent isolation	git worktree (independent working directories)
State management	Within session context	Persisted in repository files
Best suited for	Day-to-day development tasks	Large projects / feature development campaigns
Codex required?	Optional (works without it)	Essential (falls back to Claude workers if absent)

In short: If Fable Advisor is about day-to-day development efficiency, A Fable of Codexes is project-level large-scale parallel development orchestration.

Installation Steps (Beginner-Friendly)

Step 1: Verify Claude Code Is Working

Open your terminal and run:

claude --version

If a version number appears, you're good. If Claude Code isn't installed yet, check Anthropic's official documentation.

Step 2: Install the Skill

The easiest way (recommended):

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/

Step 3: Install Codex CLI (Important)

This skill uses Codex CLI as its workers. If you haven't installed it yet:

npm install -g @openai/codex
codex login

Homebrew also works:

brew install codex
codex login

Step 4: Configure Codex (Recommended)

Create ~/.codex/config.toml with default settings:

model = "gpt-5.5"
model_reasoning_effort = "xhigh"

Note: ChatGPT plan authentication has usage limits. API key authentication charges per token. Choose whichever suits your campaign scale.

Step 5: Codex Plugin (Optional)

For more advanced integration, you can also install the Codex plugin for Claude Code:

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

This enables slash commands like /codex:review and /codex:adversarial-review.

Usage — Just This Gets You Started

First Step

Launch Claude Code in any project and say just one line:

start a campaign

That's all it takes. Claude automatically:

1. Analyzes the project (surveys codebase scale)
2. Creates the docs/campaign-hq/ directory
3. Generates CAMPAIGN.md (the plan)
4. Starts dispatching workers

After That, Use Natural Language

Once the campaign starts, just give instructions normally:

"Add billing feature migration as a new phase"
"Use Sonnet for tests. Save this preference"
"Show me the current status"

Instructions are auto-saved to preferences.md, so settings carry over to your next session.

How Campaigns Work

Campaign HQ (Command Center)

When you start a campaign, a command center is created at docs/campaign-hq/ inside your project:

docs/campaign-hq/
├── CAMPAIGN.md        Plan, phases, worker list
├── LEARNINGS.md       Lessons learned and action log
├── preferences.md     Worker routing preferences
├── briefs/            Briefing documents for each worker
├── out/               Reports from workers
└── schemas/           Report format definitions

This state is saved in the repository, so even if you close your session, you can resume right where you left off the next day. This is its greatest strength.

Campaign Flow (3 Patterns)

Small projects — write the plan directly and proceed:

Conductor (Claude) writes the plan and assigns tasks directly to Codex workers

Large / unfamiliar projects — start with research:

1. Dispatch multiple research workers in parallel
2. Create a plan based on research results
3. Get approval, then start full implementation

Very large projects — proceed in waves:

Wave 1: Dispatch → Collect → Integrate → Verify
Wave 2: Dispatch → Collect → Integrate → Verify
Wave 3: ...

How Parallel Workers Work

Conflict Prevention with git worktree

When multiple workers edit the same repository simultaneously, code conflicts arise. So A Fable of Codexes uses git worktree:

Normal development:
  One person works in one folder at a time

git worktree:
  Creates an independent folder + branch per worker
  Each edits in a separate location — no conflicts even when working simultaneously

Fleet Management

The conductor manages all workers via a "fleet table":

worker-01 | User authentication | feat/auth | In progress
worker-02 | Payment API | feat/payment | Complete — awaiting review
worker-03 | Admin dashboard | feat/admin | In progress

Squad Feature

Multiple related tasks can be grouped into a "squad":

Conductor (Fable) → Squad Leader (Opus or Codex)
                       ├── Codex worker #1
                       ├── Codex worker #2
                       └── Codex worker #3
                 → Squad leader integrates into one branch
                 → Conductor verifies and merges

The squad leader directs its own Codex workers, consolidates results, and returns them to the conductor. This is a hierarchical structure that reduces the conductor's load.

How Reviews Work (Cross-Review)

A distinctive feature of A Fable of Codexes is cross-review:

Who reviews	Whose code	Why
Claude	Codex's code	Quality check from Claude perspective
Codex	Claude's code	Bug discovery from a different model lineage

Cross-reviewing across different model lineages covers blind spots inherent to a single lineage — the same thinking behind human code review.

"Bake-Off" for High-Stakes Tasks

For especially critical tasks, have both Claude and Codex implement the same spec, then adopt the better result:

Same spec → Claude implementation
          → Codex implementation
Compare → Adopt the better one (or merge the best of both)

Detailed Workflow Examples

Small Feature Addition

You: "Add two-factor authentication to the login feature"

Claude's actions:
  1. Updates campaign plan
  2. Creates a spec (brief)
  3. Dispatches one Codex worker
  4. Worker implements → reports back
  5. Claude reviews the diff → merges if OK

Full Feature Addition (Multiple Parallel Workers)

You: "Create a new user management dashboard"

Claude's actions:
  1. Surveys the project → creates a plan
  2. Dispatches 3 workers simultaneously:
     worker-1: Backend API
     worker-2: Frontend list view
     worker-3: Frontend detail/edit view
  3. Parallel implementation across 3 worktrees
  4. Sequential review → merge into integration branch
  5. Full test → merge into main

Large-Scale Refactoring (Leveraging Squads)

You: "Migrate the auth system from JWT to session-based"

Claude's actions:
  1. Architecture survey → consults fable-advisor (if available)
  2. Appoints a squad leader (Opus)
  3. Squad leader directs 3–5 Codex workers
  4. Each worker implements in parallel → squad leader integrates
  5. Claude verifies the integration branch → merges

Works Even Without Codex CLI

Even in environments without Codex CLI installed, you can compose a similar fleet using only Claude workers:

With Codex	Without Codex
Codex workers	Sonnet workers (Claude Code sub-agents)
Vendor-diverse reviews	Claude-to-Claude reviews
Maximum parallelism	Limited parallelism

The brief format and git worktree mechanism remain the same, so you can seamlessly switch if you get access to Codex later.

Who Should Choose A Fable of Codexes

Recommended for	Why
Those managing large projects	Develop multiple features in parallel
Those wanting to automate team development	Squad structure simulates team development
Those wanting to leverage Codex CLI	Designed to maximize Codex usage
Those wanting thorough state management	Campaign HQ manages all state as files
Those wanting higher review quality	Cross-review (Claude × Codex) prevents blind spots

Fable Advisor is better for	Why
Mainly day-to-day dev tasks	Simple lane separation is sufficient
Those wanting minimal setup	Installation completes in 2 commands
Those not using Codex CLI	Self-contained with Sonnet/Opus alone
Small to mid-size projects	Campaign management is overkill

FAQ

What is Codex CLI? A terminal-based AI coding agent developed by OpenAI. Powered by GPT-5.5, it automatically handles code implementation, testing, and refactoring. Install with npm install -g @openai/codex.

Can I use it without Codex CLI? Yes. Without Codex, Claude Sonnet runs as the worker. It's fully functional, though parallelism and model diversity decrease.

Can I use it together with Fable Advisor? Yes. Fable Advisor's "commitment boundary" concept works as-is. The ideal combination: consult Fable Advisor for design decisions, then run parallel implementation with A Fable of Codexes.

Can I pause a campaign midway? Yes. Even if you close the session, it auto-resumes from docs/campaign-hq/ the next time you open it. Codex workers can also be resumed using session IDs.

What is git worktree? A Git feature that creates multiple independent working directories from the same repository. git worktree add checks out a branch into a separate folder, preventing file conflicts even during parallel work.

Do workers need network access? You set the permission scope when starting a campaign. The default is Codex sandbox workspace-write level (write only within the project). You can add network access as needed.

I'm worried about API costs. You can set limits when starting a campaign. With ChatGPT plan authentication, Codex operates within plan limits; with API key authentication, it's pay-per-token. You can control costs by limiting the number of simultaneously running workers.

Reference Links

GitHub: GitHub - jvogan/a-fable-of-codexes
OpenAI Codex CLI: GitHub - openai/codex
Codex Plugin for Claude Code: GitHub - openai/codex-plugin-cc
Agent Skills Spec: Agent Skills Specification
Fable Advisor Guide (related article): Fable Advisor Complete Guide 2026

Setup Checklist

[ ] Verify Claude Code works (claude --version)
[ ] Install Codex CLI (npm install -g @openai/codex && codex login)
[ ] npx skills add jvogan/a-fable-of-codexes --skill campaign-conductor
[ ] Configure Codex (~/.codex/config.toml)
[ ] (Optional) Install Codex plugin
[ ] Run start a campaign in your project
[ ] Request your first task and verify it works

Published: 2026-07-07 | Category: AI Tools Original repository: jvogan/a-fable-of-codexes (MIT License)