Skip to content
SearchSubscribe
Expert · Lesson 10 — Multi-agent orchestration patterns
E10Expert
Expert · Lesson 10● live

Multi-agent orchestration patterns

Beyond chief-of-staff routing: parallel-spawn, gather-then-merge, race-then-cancel. When each fires and when each breaks.

18 min read · 60 min applyprereq: Operating 10 (agent routing)

Session slides — The Mechanics of Agentic Scale

Actual completion times skyrocket — 300% vs estimate
01Actual completion times skyrocket — 300% vs estimate
Efficiency collapses past six agents
02Efficiency collapses past six agents
The locking mechanism — agentic system anatomy
03The locking mechanism — agentic system anatomy
Sprint contract — done means a verifiable outcome
04Sprint contract — done means a verifiable outcome
Repeat failure
05Repeat failure
Pre-flight check: initiated
06Pre-flight check: initiated
The three-discipline loop — contracts, postmortems, gates
07The three-discipline loop — contracts, postmortems, gates
Delegation yields ROI past 5K tokens
08Delegation yields ROI past 5K tokens
Output schema — mandatory format, dimension constraints, error trap
09Output schema — mandatory format, dimension constraints, error trap
Coordinator dispatches sub-agents in parallel
10Coordinator dispatches sub-agents in parallel
Merge matrix failure — unstructured data error
11Merge matrix failure — unstructured data error
Software pipeline vs. physical engineering reality
12Software pipeline vs. physical engineering reality
Calibration gap — hallucinated synthetic data divergence
13Calibration gap — hallucinated synthetic data divergence
Three concentric loops — Collect, Iterate, Validate Gate
14Three concentric loops — Collect, Iterate, Validate Gate
Accountability loop — orchestration router, hardware and software partition
15Accountability loop — orchestration router, hardware and software partition

Beyond routing

Operating 10 covers the routing model: a chief-of-staff receives a request, classifies it, and delegates to the right specialist. That pattern is the foundation. This lesson covers what comes after it — the structural patterns for operators who need more than one specialist working simultaneously, or who need to explore multiple approaches to the same problem.

The distinction I keep coming back to. Routing is sequential delegation: one task, one specialist, one output. Orchestration is parallel coordination. N tasks or N approaches, N subagents, a coordinator that collects and synthesizes. The efficiency case is real. So is the failure case. I hit both before I understood the difference.

The companion paper TPL-2026-006 quantifies when parallel spawning produces a net positive ROI and when it doesn’t. The short version: parallelism pays when tasks are genuinely independent, outputs are structured and mergeable, and the merge work is less than the time saved. It fails when any of those conditions is absent. This lesson teaches you to check all three before spawning.

PatternStructureWhen it pays
Parallel-spawnN independent tasks → N subagents → collect all outputsTasks are truly independent; each is substantial (≥5k tokens of work); outputs need no merge logic
Gather-then-mergeOne coordinator + N research subagents → coordinator merges into unified outputResearch with clear sub-questions; well-defined merge schema; outputs are structured, not freeform
Race-then-cancelN subagents try different approaches → first valid result wins; rest are cancelledSpeculative work where any one approach might work; “working” is quickly evaluable; cancellation infrastructure exists

The three patterns are not interchangeable. Applying gather-then-merge to a problem that needs race-then-cancel wastes time. Applying race-then-cancel without cancellation infrastructure wastes money. Each section below gives you the signal for when the pattern fits and the signal for when it doesn’t.

Three orchestration patterns

Pattern 1: Parallel-spawn (independent work)

The most common pattern. The operator has N tasks with no dependencies between them — audit three datasets, research three markets, generate three asset variants. Each task is assigned to a subagent. The coordinator waits for all N outputs and then uses them independently or collects them as a set.

The key qualifier: truly independent.Tasks are parallel-spawn appropriate when the output of Task A does not affect the execution of Task B, and when the tasks don’t need to be combined — only collected. If the results need to be compared or synthesized, you have a gather-then-merge problem, not a pure parallel-spawn.

The work-size threshold matters. For tasks smaller than roughly 5,000 tokens of work (a short summary, a quick lookup, a formatting pass), the overhead of spawning a subagent (context initialization, coordination, result collection) approaches or exceeds the task cost. Below that threshold, a loop in a single agent is faster and cheaper.

SignalVerdict
Tasks have no dependencies between them and outputs are collected, not mergedGood fit
Each task is substantial (≥5k tokens of work, non-trivial execution)Good fit
Task B requires reading Task A’s output to proceedSequential, not parallel
Tasks are small (<5k tokens each)Single-agent loop is cheaper

Pattern 2: Gather-then-merge (parallel research)

One coordinator, N research subagents. Each subagent researches a defined slice. The coordinator collects all outputs and merges them into a unified artifact — a comparison table, a synthesis document, a ranked recommendation.

The pattern is powerful when the research question decomposes cleanly into sub-questions with clear boundaries. “Research vendors A, B, and C against these five dimensions” decomposes well. “Understand the competitive landscape” does not — the sub-questions overlap and the merge logic is undefined.

The load-bearing constraint is the merge schema. Each subagent must return output in the same structured format, or the coordinator spends more time normalizing outputs than the research saved. Define the schema before spawning. Include it verbatim in every subagent brief. This is the most frequently skipped step and the most common cause of gather-then-merge failure.

Pattern 3: Race-then-cancel (try multiple approaches)

N subagents attempt different approaches to the same problem. The coordinator takes the first result that meets a defined success criterion and cancels the others. Use when the problem has multiple plausible solution paths and you can’t predict which will succeed — but any one success is sufficient.

Common applications: trying three different code generation strategies for a migration, running two different data cleaning approaches against a sample, attempting two different prompt framings for a stubborn output.

The pattern only works with real cancellation. If losing subagents run to completion, you have paid for N approaches and received the value of 1. The cost structure inverts. Before committing to race-then-cancel, confirm: does your agent framework expose a cancel or interrupt signal? Does cancellation take effect promptly? If not, sequential-with-early-exit is the right pattern instead.

Three failure patterns

Where orchestration goes wrong in practice. Each failure is predictable and preventable. Hover any card to see the diagnosis.

№ 01

Spawning without a merge plan

claim looks like“An operator spawns five subagents to research five vendor candidates. Each returns a 3,000-word report. The operator now has 15,000 words of unstructured output and no plan for combining them. The merge takes three additional agent sessions. Total cost: more time than a solo sequential pass would have required.”
what’s missingThe operator treated parallelism as the goal rather than the instrument. Parallelism is only valuable if the outputs can be combined efficiently. A merge plan — the schema, the comparison dimensions, the final deliverable shape — is load-bearing. Without it, the time saved spawning is spent merging, plus overhead.
the moveWrite the merge plan before spawning. Define: what format does each subagent return? What dimensions does the coordinator compare across outputs? What does the final artifact look like? If you can write this in under five minutes, the task is parallelizable. If you can't, it isn't — and sequential is faster.
№ 02

Phantom parallelism

claim looks like“An operator spawns four subagents to pull data from the same external API simultaneously. All four calls are rate-limited to the same 10 requests-per-minute bucket. Effective throughput: identical to one sequential agent. Cost: four agents billed for wall-clock time, not productive throughput.”
what’s missingThe tasks appeared independent but shared a bottleneck resource — the rate-limited API. Parallelism requires that tasks are independent all the way down: not just independent in their goals but in their execution dependencies. A shared rate limit, a shared file lock, a shared database connection pool — any of these collapses N parallel agents to 1 effective agent.
the moveBefore spawning, map the execution dependencies, not just the task dependencies. Ask: do these tasks share any resource that could serialize them? Rate limits, file locks, connection pools, sequential external queues. If the answer is yes, either sequence the tasks explicitly or partition the resource budget before spawning (e.g., each subagent gets a distinct API key or endpoint).
№ 03

Race without cancellation

claim looks like“An operator spawns three subagents each trying a different approach to generate a working SQL migration script. The first returns a valid result after two minutes. The other two complete their full runs at six and eight minutes respectively. The operator uses only the first result. Invoice: three agents billed for three full runs.”
what’s missingRace-then-cancel requires the cancel. The pattern is only economical if the losing subagents are terminated when a winner is identified. Without cancellation infrastructure, race-then-cancel becomes run-all-to-completion, which bills for N approaches while delivering 1. The cancellation mechanism is not optional — it is the efficiency mechanism.
the moveBefore using the race pattern, confirm you have a reliable way to cancel in-flight subagents. In practice this means: the subagent framework exposes a cancel or interrupt API; the coordinator can call it on a winner signal; cancellation takes effect quickly (within one tool call cycle). If you can't cancel, use a different pattern. Sequential-with-early-exit is cheaper than race-without-cancel.

The common thread: all three failures are detectable before spawning. The merge-plan-first test surfaces failure 01. The resource-dependency check surfaces failure 02. The cancellation-infrastructure question surfaces failure 03. None of them require learning from an expensive run.

The merge-plan-first test

The decision gate for any spawning decision. Run it before launching subagents. It takes five minutes. Most operators who skip it spend two hours on the other side.

The test has three parts: output format (what exactly does each subagent return?), merge schema (what dimensions does the coordinator compare across outputs?), and final artifact (what does the deliverable look like?). If all three answers are concrete and consistent, spawn. If any answer is fuzzy, tighten it or switch to sequential.

The merge-plan-first test
Run the merge-plan-first test on this task before spawning.

Task description: [paste the task you're considering parallelizing]

Answer three questions:
1. OUTPUT FORMAT: What exactly does each subagent return?
   Define field names, types, and value constraints.
   (e.g., { price_tier: "low"|"mid"|"high", sla_tier: "standard"|"premium",
   complexity_score: 1-5, summary: string[<=100 words] })

2. MERGE SCHEMA: What dimensions will the coordinator
   compare across all subagent outputs?
   List them explicitly. If a dimension isn't in the
   output format, add it or drop it.

3. FINAL ARTIFACT: What does the deliverable look like?
   Name it. Describe its shape in one sentence.

Then apply the gate:
- If all three answers are concrete and consistent: SPAWN.
  Include the output schema in each subagent's brief.
- If any answer is fuzzy or contradictory: DO NOT SPAWN.
  Either tighten the schema (5 more minutes) or
  switch to sequential with a single structured prompt.

Output: the three answers + a SPAWN / DO NOT SPAWN verdict
with one sentence of rationale.

Outputs a SPAWN / DO NOT SPAWN verdict with rationale. Run before any parallel-spawn or gather-then-merge. Takes five minutes; prevents two-hour post-merge sessions.

The diagnostic also applies when you’re inheriting an orchestration setup someone else designed. Run the test against the existing schema. If the schema doesn’t pass, the system has latent merge debt that will surface on the next non-routine task.

TPL-2026-006 documents the ROI distribution across orchestration runs audited in the field. The finding relevant here: runs that had a documented merge plan before spawning had a 4x lower rate of post-merge remediation sessions. The five-minute investment compounds.

Annotated transcript

Operator needs to research three vendor candidates. Agent walks through the merge-plan-first test, validates the task passes, proposes the spawn configuration, then handles a follow-up about an asymmetric gather variant. Click any pinned annotation to expand the “why this turn matters” commentary.

Deciding to parallel-spawn a vendor research task

Four operator turns, four agent turns. Result: merge plan validated, subagent briefs specified, asymmetric coordinator pattern identified — before a single subagent is launched.

  1. operator

    I need to research three vendor candidates for a new data processing contract. I have spec docs for each. My first instinct is to spawn three subagents simultaneously — one per vendor — and have them report back. Does that hold up?

  2. agent

    It might. Before spawning, run the merge-plan-first test: write down what each subagent should return and how you'll combine the three outputs into a final recommendation. If you can write that in five minutes, the task is genuinely parallelizable.

    Three questions to answer:

    1. Output format: What does each subagent return? A structured object (pricing, SLA tier, integration complexity, support model) or a freeform report?
    2. Merge schema: What dimensions are you comparing across all three? If the dimensions aren't defined before spawning, the coordinator has to infer them from three differently-shaped reports — that merge is expensive.
    3. Final artifact: What does the deliverable look like? Side-by-side comparison table, ranked recommendation, something else?

    If the answer to all three is clear, parallel-spawn is the right call. If any is fuzzy, define it now — not after the subagents return.

  3. operator

    Output: structured object — pricing tier (low/mid/high), SLA tier (standard/premium), integration complexity (1-5 score), and a 100-word summary. Merge: side-by-side comparison table, then a ranked recommendation with rationale. Final artifact: one-page brief. That all feels clear.

  4. agent

    That passes the test. You have a typed schema, a defined merge operation (tabular comparison + ranking), and a named final artifact. Parallel-spawn is appropriate here.

    How to run it:

    1. Spawn with schema in the brief. Each subagent's task description includes the exact output schema — field names, types, value ranges. This prevents one subagent returning "Medium" where the schema expects "mid."
    2. Coordinator holds the merge responsibility. Don't ask each subagent to compare itself against the others — they don't have each other's outputs. The coordinator receives three structured objects and runs the comparison.
    3. Verify all three return before merging. Gather-then-merge requires all outputs before the merge step. If one subagent fails or returns a malformed object, the coordinator needs a fallback: re-run that subagent, or flag the gap explicitly rather than proceeding with a partial comparison.

    One thing to check: are all three vendors accessible through the same research pathway — same docs format, same public pricing structure? If one is substantially harder to research than the others, that subagent will take longer and the gather step will block on it. Not a reason to abandon parallel — just worth knowing the critical path before you start.

  5. operator

    Good. One follow-up: one of the three vendors is a known quantity — we've worked with them before. I'm less certain about the other two. Is there a pattern that would let me explore the uncertain two in parallel while treating the known vendor as a baseline?

  6. agent

    That's a gather-then-merge with an asymmetric coordinator role. Run it this way:

    - Subagents A and B research the two uncertain vendors against the typed schema.
    - The coordinator already holds the known vendor's profile (from your internal records) — no need to re-research it.
    - On gather, the coordinator compares A and B against the known baseline, not against each other first.

    This is more efficient than a symmetric three-way gather because you're using existing knowledge as the anchor rather than regenerating it. The merge logic is: "how does each uncertain vendor compare to the known baseline on each dimension?" — which is cleaner than a three-way comparison where all three are equally novel.

    One note: make sure your internal record for the known vendor is in the same schema format. Mismatched formats are the most common source of merge friction, and they're invisible until the coordinator tries to combine the outputs.

Orchestration pre-flight

A checklist to walk before any orchestration run. Each item is a gate, not a suggestion. A single unchecked box in the SPAWN section means do not spawn until it’s resolved.

ORCHESTRATION PRE-FLIGHT CHECKLIST

BEFORE SPAWNING (all must pass)
[ ] Merge plan defined:
    - Output format documented (field names, types,
      value constraints)
    - Merge schema documented (comparison dimensions)
    - Final artifact named and shaped
[ ] Tasks are genuinely independent:
    - No task requires another task's output to proceed
    - No task assumes another task's output as context
[ ] Resource dependencies checked:
    - Do tasks share a rate-limited API?
    - Do tasks share a file lock or connection pool?
    - If yes: either sequence or partition the resource
[ ] Work size is sufficient:
    - Each task is >= 5k tokens of work
    - If smaller: use a single-agent loop instead

PARALLEL-SPAWN SPECIFIC
[ ] Each subagent brief includes the output schema
    verbatim from the merge plan
[ ] Each brief includes explicit scope boundaries
    (what not to do) to prevent overlap
[ ] Each brief specifies a structured error return
    (not silence) if the task cannot be completed

GATHER-THEN-MERGE SPECIFIC
[ ] Coordinator role is documented:
    - Receives all outputs before merging
    - Does not ask subagents to compare each other
[ ] Partial-gather handling defined:
    - What if one subagent fails?
    - Re-run, flag, or proceed with gap noted?
[ ] Schema alignment verified:
    - All subagents return the same format
    - Known-baseline data (if any) is in the same format

RACE-THEN-CANCEL SPECIFIC
[ ] Success criterion defined before spawning:
    - What does "working result" mean?
    - Is it quickly evaluable (< 1 tool call)?
[ ] Cancellation infrastructure confirmed:
    - Framework exposes cancel/interrupt API
    - Cancellation is prompt (< 1 tool call cycle)
[ ] If cancellation is NOT available:
    - Switch to sequential-with-early-exit
    - Do not run race-then-cancel without it

POST-RUN
[ ] Run the post-hoc audit prompt
[ ] Log: spawn time + gather time + merge time
[ ] Compare to sequential estimate
[ ] If merge time > time saved: update CLAUDE.md
    with the task class and its correct pattern

The post-run log is what makes the discipline compound.Orchestration ROI varies by task class. Logging actual times builds a calibration set. After five audited runs, most operators know exactly which of their recurring task types benefit from orchestration and which don’t. Without the log, that knowledge never accumulates.

Prompt kit

Three prompts: the merge-plan-first gate, writing a parallel-spawn brief, and auditing an orchestration run post-hoc. Save in your CLAUDE.md or project snippets file.

The merge-plan-first test
Run the merge-plan-first test on this task before spawning.

Task description: [paste the task you're considering parallelizing]

Answer three questions:
1. OUTPUT FORMAT: What exactly does each subagent return?
   Define field names, types, and value constraints.
   (e.g., { price_tier: "low"|"mid"|"high", sla_tier: "standard"|"premium",
   complexity_score: 1-5, summary: string[<=100 words] })

2. MERGE SCHEMA: What dimensions will the coordinator
   compare across all subagent outputs?
   List them explicitly. If a dimension isn't in the
   output format, add it or drop it.

3. FINAL ARTIFACT: What does the deliverable look like?
   Name it. Describe its shape in one sentence.

Then apply the gate:
- If all three answers are concrete and consistent: SPAWN.
  Include the output schema in each subagent's brief.
- If any answer is fuzzy or contradictory: DO NOT SPAWN.
  Either tighten the schema (5 more minutes) or
  switch to sequential with a single structured prompt.

Output: the three answers + a SPAWN / DO NOT SPAWN verdict
with one sentence of rationale.
Write a parallel-spawn task brief
Write a subagent task brief for a parallel-spawn.

Context: I am spawning [N] subagents simultaneously.
Each subagent will handle: [describe the slice]

The brief must include:
1. SCOPE: What this subagent researches/produces.
   (One paragraph, no ambiguity about boundaries.)
2. OUTPUT SCHEMA: Exact format required.
   (Field names, types, value constraints — copy from
   the merge plan. The coordinator will reject any
   output that doesn't match this schema.)
3. WHAT NOT TO DO: Explicitly exclude adjacent work
   the subagent might assume is in-scope.
   (This prevents overlap with other subagents.)
4. FAILURE SIGNAL: What should the subagent return
   if it cannot complete the task?
   (A structured error object, not silence.)

Tone: operator-grade. Short sentences. No preamble.

Output: the task brief, ready to paste.
Audit a spawning decision post-hoc
Audit this orchestration run after the fact.

What I spawned: [describe what you ran]
What I got back: [describe the outputs]
Time to spawn + gather: [estimate]
Time to merge: [estimate]
Time if done sequentially (estimate): [estimate]

Diagnose:
1. Was the merge plan defined before spawning?
   If not, how much merge time was avoidable?
2. Were there hidden resource bottlenecks that
   serialized the parallel agents? (rate limits,
   shared files, sequential queues)
3. If this was a race pattern, were losing agents
   cancelled? If not, what did uncancelled runs cost?
4. Net verdict: did parallelism save time, break even,
   or cost more than sequential?

Output: a one-paragraph postmortem + one action item
for the next time this task class comes up.

Apply this — orchestrate one task the right way

~60-minute exercise.Gate, brief, run, audit. Don’t spawn without a merge plan.

Your first audited orchestration run

Each step takes 10-20 minutes. Progress saves automatically.

0/5
  1. 01Identify one task in your current backlog that looks parallelizable. Run the merge-plan-first test on it before spawning anything.The test takes five minutes. Write the output format, merge schema, and final artifact explicitly. If you can't, the task isn't parallelizable yet — tighten the schema or switch to sequential.
  2. 02For a task that passed the merge-plan-first test, write the subagent task briefs using the second prompt in the kit.Each brief should include the output schema verbatim from the merge plan. Spend five minutes on the 'what not to do' section — that's where subagent scope overlap hides.
  3. 03After running any parallel-spawn, run the post-hoc audit prompt. Calculate whether parallelism actually saved time.Most operators don't audit their orchestration runs. One audit surfaces the pattern: which task classes parallelize well, which don't. That knowledge compounds across future runs. See TPL-2026-006 for the ROI model.
  4. 04Find one task where you used (or were tempted to use) the race pattern. Check whether you have a real cancellation mechanism. If not, document why sequential-with-early-exit is the safer default.Race-then-cancel is the most frequently misapplied pattern. The cancellation infrastructure question is binary: you either have it or you don't. If you don't, the pattern costs more than sequential in the typical case.
  5. 05Write a one-paragraph rule for your CLAUDE.md that governs when your agents may spawn subagents. Include: the merge-plan-first gate, the phantom-parallelism check, and the cancellation requirement for race patterns.This converts the lesson from operator memory into structural enforcement. Future agent sessions read the rule; they don't rely on you remembering it. That's the discipline that compounds.
Expert tier · what's next

After this lesson