The Orchestrator Is Not the Worker

I run a brand with surfaces in five places. Content (articles, podcast, Instagram, TikTok). Design (covers, illustrations, dashboards). Three book IPs with their own reference trees. A retreat operation with its own ops folder. A funnel build with its own dependency-ordered handoff. One operator. One brain. One Claude session is not enough to hold all of that.

A session that tries to hold all of it does not fail loudly. It drifts. Captions start picking up vocabulary from design briefs and book-IP references that have no business there, and the token budget burns on context the session never actually uses.

The fix is structural, not stylistic.

Claude is the dispatcher

The Claude Code session at the project root does not write. It dispatches.

Every actual unit of work lives in a sandbox. A sandbox is a folder with its own CLAUDE.md, its own scoped memory, its own reference files, and a single job description. The orchestrator session reads the request, picks the right sandbox, writes a brief, and hands it off.

The orchestrator is short on context but long on map. The sandbox is short on map but long on context for one thing. That asymmetry is the whole point.

Workers, named

Sanitized worker registry.

Each row is a separate Claude Code session, started fresh, scoped to one folder. No worker reads outside its sandbox without a brief authorizing it.

Why this exists

A cold-start session is expensive. The first thing it does is load context. If the context is “the whole brand,” every cold start is a tax. If the context is “the content sandbox,” the cold start loads four reference files instead of forty. Same model, same operator, an order of magnitude less token spend, and a session that already knows the voice rules for what it is about to do.

The second reason is voice. Specialists hold voice. Generalists drift. A content worker that only ever sees content rules holds the brand voice better than a generalist juggling content, design, books, and retreat ops at the same time. The drift problem is real, and the fix is not “remind it harder.” The fix is to remove the surfaces it does not need.

The third reason is parallelism. Two workers can run at the same time without colliding, because they share no state and no working directory. The orchestrator dispatches both, gets both back, and stitches.

Briefs are the contract

A worker never reads orchestrator history. A worker reads a brief, cold, and executes. If the brief is good, the worker ships. If the brief is ambiguous, the worker writes a question file and stops.

This is the boundary. The orchestrator owns what gets done; the worker owns how it gets done. Briefs are the only thing crossing the boundary.

The shape of that brief — fields, verify section, escalation path, returns-with checklist — is what makes the whole pattern hold under load. It is also the part most operators get wrong on the first three tries.

What this is not

This is not subagents. Subagents share a parent session’s context and exit when the parent ends. Workers are independent sessions with their own memory and their own lifespan. The orchestrator does not call them; it briefs them.

This is not multi-agent orchestration in the LangGraph sense. There is no message bus. There is no shared state machine. There is a folder with a brief in it, another folder with the rendered output, and an operator who moves between them.

This is also not the standard Claude Code “one project, one CLAUDE.md” pattern. That pattern works while a project has one surface. It stops working the day the brand has five.

Two companions in this series: Five locked rules of daily dispatch and Three categories of external workers.