The dispatch protocol is the contract

The constellation ships as a Claude Code plugin marketplace, and that fact makes the whole pipeline look locked to one runtime. It is not. A Kimi K2.6 session in another project ran the book-proposal recipe end-to-end — dispatched McCarthy, Gottlieb, and Maya Angelou across two plugins, and the Plan → Build → QA → Review shape held. The marketplace is the distribution. The runtime is something else.

This lesson assumes you have already dispatched a sub-agent at least once. If you have not, go back to l8 (Plugins ship prompts. Projects ship renders) and run one before continuing. The architectural claim only lands once the protocol is in your hands.

The container, not the truck

What carries between runtimes is not the model and not the CLI. It is the dispatch protocol. Three rules, all visible from the brief you write:

1. The brief is self-contained — every file path, every voice rule, every constraint goes in the prompt.
2. The sub-agent reads the project bible at .great-authors/ in fresh context before writing.
3. Output goes to a deterministic path on disk, not back into the conversation.

Look at how shipping containers move. The forty-foot box is the contract — its corners, its hooks, its dimensions are standardized first. After that, every port that handles intermodal cargo can move it. The trucks change. The cranes change. The ships change. The container does not. The dispatch protocol has the same property. The brief is the corner-casting, the bible read is the hook, the deterministic output path is the chassis. Anything that can move that shape can move your recipes.

What carries, what does not

Two columns. This is the audit you need.

Carries:

• Persona files (plain markdown, no runtime calls inside)
• The bible at .great-authors/
• The dispatch-and-read-first pattern
• The deterministic output path
• The Plan → Build → QA → Review pipeline shape

Does not carry:

• The Agent tool surface itself — other CLIs may not expose subagent_type cleanly
• The plugin marketplace
• Per-project enablement in .claude/settings.json
• Slash skills like /team-build

If a persona file contains a line like "use the Agent tool to dispatch...", that file is coupled to one harness. Rewrite it in protocol terms: "dispatch this persona with a self-contained brief." The first phrasing dates within a year. The second reads correctly in any runtime that supports sub-agent dispatch.

Pick the model by what the orchestrator is doing

Routing four parallel dispatches and stitching their outputs is not reasoning-heavy work. The reasoning happens inside the personas. The orchestrator is switching cables. When billing matters, route the orchestrator to a cheaper model — Sonnet, Kimi K2.6 — and let Opus run only when the integration step itself requires real reasoning. Run the same recipe twice, once with each, and read the artifacts side by side. Most come back indistinguishable.

The pinch-hit byline

When a plugin you depend on is not loaded in the current runtime, the orchestrator can absorb the persona's job. But the substitution gets named. The byline string looks like this:

Researcher: Robert Caro (substituted: direct web research + synthesis)

The recipe still runs. The case study stays honest. Without the explicit substitution, the prose drifts from register and you cannot tell from the artifact whether the constellation worked or whether the orchestrator faked it.

If you get stuck

• The persona file references the harness. Lines like "use the Agent tool" or "set this in settings.json" couple the prompt to one runtime. Rewrite in protocol terms — name the dispatch action, not the CLI.
• The orchestrator absorbed the persona's job without saying so. The output reads coherent but flat. Stop. Either dispatch the persona, or add the byline string that names what you covered.
• The README does not separate protocol from harness. The next operator porting the work cannot tell what is load-bearing. Split it into two sections — one paragraph each.

Cross-reference

Lesson 8 (Plugins ship prompts. Projects ship renders) is the file-separation rule this lesson depends on. The persona files belong to the plugin, the bible and renders belong to the project, the dispatch couples them — and the dispatch is what carries.

Deliverable

Open one persona file from your own constellation. Find every line that references the Agent tool, the plugin marketplace, or .claude/settings.json. Rewrite each in protocol-level terms. Then update your project README to split protocol-level requirements (dispatch, briefs, bible, deterministic paths) from harness-level requirements (the CLI you currently run on). Two sections, two paragraphs each.

Further reading

• "The Orchestrator Does Not Write" — the same separation that makes the orchestrator role coherent is what makes the dispatch protocol portable.