Chapter 8: Collaboration: When one agent is not enough
This introduction explains why collaboration helps when work can be divided, but adds costs that a single agent may avoid.
After this chapter you will be able to
- Task shape and collaboration. Explain why multiple agents helped with the broad research task but did not help with sequential planning: independent pieces could be searched in parallel, while the same multi-agent choice hurt a task with a different dependency shape.
- Single-agent admission rule. State the rule for adding another agent: keep one agent if it meets the acceptance criteria; otherwise, the newcomer must supply a missing contribution that can be reconnected to the original goal. Explain the coordination risks weighed against added capacity or viewpoints.
- Responsibility across agent boundaries. Explain what changes when work moves from one agent to multiple agents, and why shared storage alone does not convey each agent’s decision state.
- Reasons and boundaries for splitting. Describe the first two gates for adding an agent: identify a substantive reason to split the work and define each agent’s ownership and limits.
- Team value against baseline. Explain how to test whether a multi-agent team improves on one agent and why apparent parallel activity is not enough.
- Handoff information loss. Explain how a chain can produce the wrong result even when each specialist performs its phase well, using the lost account condition in the payment-bug example.
- Sequential specialist ownership. Describe when to use Handoff Chain and how ownership moves through its specialist phases.
- Decision preserving handoff packet. Explain what the typed handoff packet must preserve and how its receiver can respond.
- Seat request handoff. Trace how triage hands a seat-change request to a specialist and regains ownership afterward. Describe what the specialist does when information is missing or the request falls outside its role.
- Shared storage versus handoff context. Distinguish a shared workspace from the context passed in a handoff, using the triage and seat agents as an example.
- Coding agent handoff flow. Trace how a top-level dialog can hand a defect from a read-only explorer to an implementer and then to a test runner, while retaining responsibility for the overall task.
- Specialist phase selection. Explain when separating coding work into specialist phases is useful and when one agent may be clearer.
- Subagent handoff contract. Describe what is specified for a subagent and what the main dialog retains at each transition.
- Missing handoff information. Explain how an omitted constraint can make the receiving agent answer the wrong problem, and why the receiver should check the handoff package before starting.
- Propagated weak framing. Explain why even a complete handoff can spread a weak diagnosis, and describe what should accompany its conclusion.
- Unnecessary sequential waiting. Explain the latency cost of a Handoff Chain and distinguish work that truly needs a chain from investigations that need not wait for one another.
- Fan-Out/Gather collaboration shape. Describe how a coordinator assigns independent work to workers and reconnects their outputs at a gather point. Distinguish this parallel stage from the larger hierarchical system, in which the lead retains and revises the plan.
- Genuinely independent branches. Explain how to choose a partition that lets branches proceed without waiting or duplicating the same reasoning, and why a perspective label alone does not establish independence.
- Accountable result gathering. Explain how compatible worker records are gathered into an owned result, including coverage checks, failed-worker handling, and preservation of contradictions. State why the merge must not require repeating every branch's work.
- Shared Blocker Collapse. Explain why the compiler project’s apparent parallelism collapsed during Linux-kernel compilation.
- Restoring Independent Investigations. Describe how the team changed the experiment to recover independent investigations, and state the practical test for deciding whether workers can make progress in parallel.
- Disagreement-aware result gathering. Explain how a gather step combines duplicate findings while keeping incompatible recommendations and consequential minority findings visible. Describe the common fields parallel code-review workers should return so their findings can be compared.
- Parallel work ownership and integration. Describe how a coordinator partitions parallel coding work and where responsibility for testing the combined change sits.
- Duplicate worker effort. Explain why differently labeled workers may still duplicate work, and how to give them distinct assignments and deduplicate their results.
- Unresolved recommendation conflicts. Describe why gathering individually sound recommendations may leave an unresolved conflict, and what to do when the disagreement affects a consequential decision.
- Single-agent baseline comparison. Explain how to check whether Fan-Out/Gather is worthwhile compared with a single agent.
- Claim Centered Review Roles. Explain how the writer, reviewer, and judge have different responsibilities around a specific claim, and trace how a finding leads to a changed artifact and another review.
- Independent Evidence And Boundaries. Describe why opposing role prompts alone are not enough for strong independence, and state the boundaries that make the review a defined exchange.
- Review Fit And Judgment. Explain when Adversarial Review is useful and distinguish when an agent versus a human should judge the evidence.
- Three review mechanisms. Distinguish Generator-Critic, Adversarial Review, and Approval Gate by what each decides. Explain why adding a second agent is not enough to make feedback adversarial.
- Critic Assistance and Human Judgment. Explain what the CriticGPT study suggests about assisted code review and why its critiques still require human judgment.
- Tests Before Adversarial Review. Distinguish claims a test can settle from claims that warrant Adversarial Review.
- Claim-based review roles. Explain how the developer assigns writer, reviewer, and judge responsibilities for a specific claim and its possible failure, using an authentication change as the example.
- Bounded review and escalation. Explain when another review round is worthwhile, when a resolved issue reopens, and when an unresolved dispute escalates.
- Performative disagreement and useful findings. Explain how rewarding objection count can produce harmless objections, and describe what makes a review finding useful instead.
- Shared convergence despite role labels. Explain why agents assigned opposing review roles can still agree without independent judgment, and state the section's remedy.
- Endless review and escalation. Explain why review needs a burden of proof and stop rule, and describe what to do with a claim that remains unresolved.
- Manager visibility problem. Explain why adding workers does not by itself keep a manager informed: workers may assume nonexistent shared state, and their discoveries may not reach the manager or other workers.
- Hierarchical ownership of work. Describe when Hierarchical Delegation fits and how responsibilities divide: the manager maintains and revises a dependency-aware plan and integrates the result, while workers execute bounded deliverables and return evidence.
- Hierarchy versus independent branches. Distinguish Hierarchical Delegation from Fan-Out/Gather by their control responsibilities, not by whether they launch multiple workers.
- Worker task context. Explain what a manager should give a worker so its result serves the overall goal without passing along the manager’s entire history.
- Worker reports and plan revision. Describe what a worker should report upward when its assignment breaks down, and how the manager should respond when the report challenges a decision or the overall plan.
- Manager-Owned Subagent Tasks. Describe how a main coding-agent dialog delegates a bounded task to a subagent while retaining the user's goal and integrating the result. State what the parent must pass to the worker.
- Runtime-Enforced Worker Permissions. Explain why a worker's tool and permission configuration, rather than its role prompt, must bound what it can do.
- Manager decomposition risk. Explain why a weak manager plan can misdirect capable workers and how to catch that before costly work proceeds.
- Worker interface alignment. Describe how a worker can complete its assigned task yet harm the larger effort, and how to check for that failure.
- Cascading artifact failure. Trace how a weak artifact can affect dependent tasks and describe the safeguards given here.
- Single-agent outcome baseline. Explain why a multi-agent team should be tested on the same task against a credible single-agent baseline, with task outcomes measured before coordination behavior.
- Pattern-specific coordination seams. Describe what to inspect at the coordination seam for each collaboration pattern: Handoff Chain, Fan-Out/Gather, Adversarial Review, and Hierarchical Delegation.
- Trace evidence and limits. Distinguish what a collaboration trace can reveal from what it cannot prove, and describe the additional fields to record for consequential work.
- Release collaboration sequence. Trace how the disputed authentication change moves through Hierarchical Delegation, Fan-Out/Gather, Adversarial Review, and Handoff Chain before the manager accepts the release.
- Collaboration control points. Explain why a collaboration design should start by locating control rather than choosing a framework product. Identify where the plan lives, who dispatches work, where shared state persists, and who accepts the result.
- Implementation layers versus patterns. Distinguish an application's framework, runtime, or harness support from its collaboration pattern, using the Deep Agents example.
- Three collaboration communication channels. Distinguish agent-to-agent, human-to-agent, and human-to-human communication by what each carries and why they should be designed separately.
- Human accountability without universal approval. Explain why having all three channels requires human ownership, opportunities for risk-based intervention, and durable decision records, but not approval at every agent transition.
- Architecture before protocol selection. Explain why a collaboration pattern should be chosen before selecting a communication protocol.
- Distributed review and claim challenge. Describe how Argus distributes one code diff to security, style, and complexity workers, preserves their structured findings at the gather point, and sends a consequential claim through Adversarial Review before the caller accepts it.
What it builds on
- Scale only after hitting a structural wall (chapter 2) · The decision to scale beyond one agent only after encountering a structural limit.
- Start with the single-agent default (chapter 2) · The single-agent default.
- Memory and collaboration: A boundary (chapter 4) · The distinction between memory and collaboration.
- What multi-agent costs you (chapter 2) · The costs of using multiple agents.
- Pattern: Generator-Critic (chapter 7) · Introduces Generator-Critic as a way to check and revise an artifact.
- Pattern: Guardrail Sandwich (chapter 6) · The Guardrail Sandwich as a way to constrain action, here applied at each delegation boundary.
Section by section
Introduction
This introduction explains why collaboration helps when work can be divided, but adds costs that a single agent may avoid.
- Task shape and collaboration: Explain why multiple agents helped with the broad research task but did not help with sequential planning: independent pieces could be searched in parallel, while the same multi-agent choice hurt a task with a different dependency shape.
Why it matters: Whether work can be divided is a better reason to add agents than difficulty alone. - Single-agent admission rule: State the rule for adding another agent: keep one agent if it meets the acceptance criteria; otherwise, the newcomer must supply a missing contribution that can be reconnected to the original goal. Explain the coordination risks weighed against added capacity or viewpoints.
Why it matters: This rule keeps collaboration from becoming extra coordination with no benefit to the task.
Key terms: lead agent, subagents, independent pieces of work, dependency shape, acceptance criteria, working context, coordination cost
8.1 What collaboration changes
The section defines collaboration as a transfer of responsibility between agents and gives three gates for deciding whether adding an agent is worthwhile.
- Responsibility across agent boundaries: Explain what changes when work moves from one agent to multiple agents, and why shared storage alone does not convey each agent’s decision state.
Why it matters: It keeps a multi-agent design focused on accountable work rather than merely adding more model calls. - Reasons and boundaries for splitting: Describe the first two gates for adding an agent: identify a substantive reason to split the work and define each agent’s ownership and limits.
Why it matters: A justified split with clear boundaries makes each agent’s contribution possible to assess and integrate. - Team value against baseline: Explain how to test whether a multi-agent team improves on one agent and why apparent parallel activity is not enough.
Why it matters: A baseline exposes whether collaboration earns its added cost and integration effort.
Key terms: Collaboration, boundary between agents, decision state, shared storage, three gates, independent search areas, boundaries, separate authority, single-agent baseline, outcome quality
8.2 Pattern: Handoff Chain
Handoff Chain moves sequential work between specialists using an explicit package that preserves decision-critical state as ownership changes.
- Handoff information loss: Explain how a chain can produce the wrong result even when each specialist performs its phase well, using the lost account condition in the payment-bug example.
Why it matters: A locally successful phase cannot compensate for a lost requirement. - Sequential specialist ownership: Describe when to use Handoff Chain and how ownership moves through its specialist phases.
Why it matters: Clear phase ownership makes it possible to transfer work without assuming every specialist has the same role or permissions. - Decision preserving handoff packet: Explain what the typed handoff packet must preserve and how its receiver can respond.
Why it matters: The next specialist needs enough grounded, actionable state to take ownership safely rather than reconstruct or blindly trust a summary. - Handoff boundary health: Describe how to define and assess a phase boundary without making its packet too thin or unbounded.
Why it matters: Boundary design should give the receiver what it needs to decide without forcing rediscovery or transferring the entire history.
Key terms: handoff, condition, ownership, Handoff Chain, Collaboration × Chain, analyzer, implementer, verifier, typed packet, authoritative artifact
8.2.1 Walking through an airline-support handoff
This section walks through an airline-support handoff, showing what information must pass between agents, how a specialist returns a task, and why shared storage is not enough.
- Seat request handoff: Trace how triage hands a seat-change request to a specialist and regains ownership afterward. Describe what the specialist does when information is missing or the request falls outside its role.
Why it matters: A clear handoff lets each agent act within its responsibility without losing the information needed to continue the conversation. - Return states and routing: Explain what the two Agent2Agent return-path states indicate and who decides where a paused or rejected task goes next.
Why it matters: A task state reports what happened; it does not replace the application's responsibility for routing. - Shared storage versus handoff context: Distinguish a shared workspace from the context passed in a handoff, using the triage and seat agents as an example.
Why it matters: Sharing records alone can leave the receiving agent without the reason it was asked to act.
Key terms: triage agent, seat specialist, handoff, evidence of the action, Agent2Agent protocol, TASK_STATE_INPUT_REQUIRED, TASK_STATE_REJECTED, shared workspace, shared context, decision state
8.2.2 A chain in a coding agent
This section shows how a coding agent can coordinate isolated specialists in a handoff chain and when that split is worth making.
- Coding agent handoff flow: Trace how a top-level dialog can hand a defect from a read-only explorer to an implementer and then to a test runner, while retaining responsibility for the overall task.
Why it matters: A handoff must carry the evidence the next specialist needs rather than assuming it shares the previous specialist’s context. - Specialist phase selection: Explain when separating coding work into specialist phases is useful and when one agent may be clearer.
Why it matters: Specialists are useful for meaningful boundaries, not merely because a task can be divided into steps. - Subagent handoff contract: Describe what is specified for a subagent and what the main dialog retains at each transition.
Why it matters: An explicit handoff defines both what a specialist may do and how its result or failure returns to the coordinator.
Key terms: top-level dialog, subagents, fresh, isolated context, handoff, specialists, responsibility, tools, permissions, role, relevant context
8.2.3 When Handoff Chain breaks
This section explains three ways a Handoff Chain can fail and how to limit each risk.
- Missing handoff information: Explain how an omitted constraint can make the receiving agent answer the wrong problem, and why the receiver should check the handoff package before starting.
Why it matters: A plausible answer is not useful if the receiving agent was given the wrong problem. - Propagated weak framing: Explain why even a complete handoff can spread a weak diagnosis, and describe what should accompany its conclusion.
Why it matters: Later agents need a way to question a diagnosis, not merely inherit it. - Unnecessary sequential waiting: Explain the latency cost of a Handoff Chain and distinguish work that truly needs a chain from investigations that need not wait for one another.
Why it matters: Recognizing independent work prevents a chain from imposing avoidable delays.
Key terms: information loss, handoff, package, missing evidence, framing propagation, weak diagnosis, evidence, invalidation conditions, independent investigation, sequential latency
8.3 Pattern: Fan-Out/Gather
This section explains how Fan-Out/Gather divides a task into independent concurrent branches and combines their results without losing coverage or conflicting evidence.
- Fan-Out/Gather collaboration shape: Describe how a coordinator assigns independent work to workers and reconnects their outputs at a gather point. Distinguish this parallel stage from the larger hierarchical system, in which the lead retains and revises the plan.
Why it matters: This distinction helps you identify where parallel collaboration occurs without treating the whole system as a single parallel pattern. - Genuinely independent branches: Explain how to choose a partition that lets branches proceed without waiting or duplicating the same reasoning, and why a perspective label alone does not establish independence.
Why it matters: A real partition avoids paying for parallel workers that duplicate effort or leave the gather agent to redo their work. - Accountable result gathering: Explain how compatible worker records are gathered into an owned result, including coverage checks, failed-worker handling, and preservation of contradictions. State why the merge must not require repeating every branch's work.
Why it matters: A reliable gather step produces a usable combined answer without hiding gaps or disputed evidence.
Key terms: Fan-Out/Gather, Collaboration × Parallel, hierarchical, branches, partition, duplicate work, return schema, completion policy, merge rule, contradictions
8.3.1 When apparent parallelism collapses
This section shows why adding workers does not create useful parallelism when they share a blocker, and how to restore independent work.
- Shared Blocker Collapse: Explain why the compiler project’s apparent parallelism collapsed during Linux-kernel compilation.
Why it matters: Worker count matters less than whether workers have independent paths to progress. - Restoring Independent Investigations: Describe how the team changed the experiment to recover independent investigations, and state the practical test for deciding whether workers can make progress in parallel.
Why it matters: Checking for independent evidence before adding workers avoids costly work on the same bottleneck.
Key terms: shared failure, dependency graph, useful parallel work, GCC, known-good compiler, better partition, shared dependency
8.3.2 Gathering without hiding the minority
This section explains how to gather parallel workers’ findings without concealing disagreements or important findings reported by only one worker.
- Disagreement-aware result gathering: Explain how a gather step combines duplicate findings while keeping incompatible recommendations and consequential minority findings visible. Describe the common fields parallel code-review workers should return so their findings can be compared.
Why it matters: A tidy merged report can be misleading if it erases a real conflict or an important finding from one worker. - Adjudication of consequential disagreements: Describe how the Catalog example handles worker disagreement and what happened after a classification disagreement was resolved.
Why it matters: The example shows why a disputed result may need an owner’s judgment instead of an automatic merge.
Key terms: gather step, underlying cause, incompatible recommendations, material finding, uncertainty, supervisor, learning loop, adjudicated, visual context
8.3.3 Parallel work in coding agents
This section explains how coding agents can work in parallel while controlling conflicts over shared resources and validating the combined result.
- Limits of worktree isolation: Explain why separate Git worktrees prevent workers from editing the same checkout but do not eliminate conflicts over other shared resources.
Why it matters: Separate files are not enough to make parallel work independent. - Parallel work ownership and integration: Describe how a coordinator partitions parallel coding work and where responsibility for testing the combined change sits.
Why it matters: Explicit ownership prevents parallel implementations from colliding, while integration tests check that their combined work holds together.
Key terms: Git worktrees, conflict domains, coordinator, work partition, write partition, gather point, integration tests
8.3.4 When Fan-Out/Gather breaks
This section explains how to recognize duplicate work and unresolved conflicts in Fan-Out/Gather, then check whether it improves on a single-agent approach.
- Duplicate worker effort: Explain why differently labeled workers may still duplicate work, and how to give them distinct assignments and deduplicate their results.
Why it matters: Parallel workers add cost without adding much evidence when they repeat the same search. - Unresolved recommendation conflicts: Describe why gathering individually sound recommendations may leave an unresolved conflict, and what to do when the disagreement affects a consequential decision.
Why it matters: The gathered answer must expose consequential trade-offs rather than silently bury them. - Single-agent baseline comparison: Explain how to check whether Fan-Out/Gather is worthwhile compared with a single agent.
Why it matters: Branch speed alone can mask the cost of merging and repairing the final result.
Key terms: workers, evidence surfaces, claims, artifacts, deduplicate by cause, unresolved integration, concatenation, unconstrained synthesis, burden of proof, single-agent baseline
8.4 Pattern: Adversarial Review
This section introduces Adversarial Review as a bounded, evidence-driven exchange in which a reviewer challenges a writer’s claim and a judge decides what the evidence supports.
- Claim Centered Review Roles: Explain how the writer, reviewer, and judge have different responsibilities around a specific claim, and trace how a finding leads to a changed artifact and another review.
Why it matters: The exchange tests a specific claim against evidence instead of treating another opinion as a verdict. - Independent Evidence And Boundaries: Describe why opposing role prompts alone are not enough for strong independence, and state the boundaries that make the review a defined exchange.
Why it matters: A reviewer is more useful when it can bring evidence the writer did not simply supply or frame. - Review Fit And Judgment: Explain when Adversarial Review is useful and distinguish when an agent versus a human should judge the evidence.
Why it matters: The pattern adds value when a consequential claim needs challenge, without handing a high-stakes verdict to an inappropriate judge. - Useful Finding Measures: State what to measure to tell whether Adversarial Review adds useful findings beyond self-review.
Why it matters: These measures show whether the additional review produces useful evidence at a worthwhile cost.
Key terms: writer, reviewer, judge, claim, changed artifact, independence, clean context, burden of proof, search boundary, decision rule
8.4.1 Three mechanisms that look like review
Distinguishes three kinds of inspection by the decisions they make and explains what makes a review genuinely adversarial.
- Three review mechanisms: Distinguish Generator-Critic, Adversarial Review, and Approval Gate by what each decides. Explain why adding a second agent is not enough to make feedback adversarial.
Why it matters: These distinctions help you choose the right review mechanism instead of treating every extra reviewer as adversarial review.
Key terms: Generator-Critic, Adversarial Review, Approval Gate, independent security reviewer, judge
8.4.2 Evidence from code review systems
The section uses code-review systems to show the value and limits of independent critique, and when a test is a better choice than another reviewer.
- Critic Assistance and Human Judgment: Explain what the CriticGPT study suggests about assisted code review and why its critiques still require human judgment.
Why it matters: A useful second opinion should strengthen review without becoming an unquestioned verdict. - Independent Review With Task Context: Describe how Devin Review separates review from code-writing context while retaining the task context needed to judge the change, and qualify its reported results.
Why it matters: A fresh reviewer still needs enough task information to judge the change against the actual request. - Tests Before Adversarial Review: Distinguish claims a test can settle from claims that warrant Adversarial Review.
Why it matters: Choosing the simplest adequate check avoids spending a second review on questions a test can answer.
Key terms: CriticGPT, defect claim, human judgment, Devin Review, clean context, wider task context, mechanically testable claims, Adversarial Review, counterevidence
8.4.3 Running a bounded review
This section explains how to assign distinct responsibilities, share review evidence without losing independence, and limit an adversarial review loop.
- Claim-based review roles: Explain how the developer assigns writer, reviewer, and judge responsibilities for a specific claim and its possible failure, using an authentication change as the example.
Why it matters: Distinct responsibilities make the review test a specific claim rather than merely gather opinions. - Shared evidence and independent review: Describe how the writer and reviewer can work from the same current artifact while preserving the reviewer’s independent approach.
Why it matters: Shared evidence keeps the discussion grounded without making the reviewer simply follow the writer’s thinking. - Bounded review and escalation: Explain when another review round is worthwhile, when a resolved issue reopens, and when an unresolved dispute escalates.
Why it matters: A bounded loop directs effort toward changes that could affect the decision and gives consequential deadlocks an exit.
Key terms: writer, security reviewer, judge, safety claim, verdict, current artifact, review record, shared issue list, working contexts, review budget
8.4.4 When Adversarial Review breaks
This section explains three ways Adversarial Review can fail and how to keep findings useful, judgments independent, and review bounded.
- Performative disagreement and useful findings: Explain how rewarding objection count can produce harmless objections, and describe what makes a review finding useful instead.
Why it matters: A long list of objections is not necessarily a better review. - Shared convergence despite role labels: Explain why agents assigned opposing review roles can still agree without independent judgment, and state the section's remedy.
Why it matters: Agreement is less reassuring when both reviewers are likely to make the same judgment. - Endless review and escalation: Explain why review needs a burden of proof and stop rule, and describe what to do with a claim that remains unresolved.
Why it matters: A review that runs out of time or budget has not necessarily resolved the disputed claim.
Key terms: performative disagreement, affected claim, evidence, consequence, verdict changes, shared convergence, source of judgment, independence, endless review, burden of proof
8.5 Pattern: Hierarchical Delegation
Introduces Hierarchical Delegation as a way to coordinate dependent worker tasks under a manager that maintains the plan and integrates the results.
- Manager visibility problem: Explain why adding workers does not by itself keep a manager informed: workers may assume nonexistent shared state, and their discoveries may not reach the manager or other workers.
Why it matters: More workers do not help if the agent coordinating them cannot see information that changes the plan. - Hierarchical ownership of work: Describe when Hierarchical Delegation fits and how responsibilities divide: the manager maintains and revises a dependency-aware plan and integrates the result, while workers execute bounded deliverables and return evidence.
Why it matters: Clear ownership lets workers act locally without losing a coherent overall result. - Hierarchy versus independent branches: Distinguish Hierarchical Delegation from Fan-Out/Gather by their control responsibilities, not by whether they launch multiple workers.
Why it matters: The number of workers alone cannot tell you which collaboration pattern the task requires.
Key terms: manager, child agents, shared state, Hierarchical Delegation, bounded deliverables, explicit dependencies, global coherence, plan revision, Fan-Out/Gather, independent branches
8.5.1 What the manager and workers need from each other
This section explains what a manager must pass to workers and how workers should report problems that require the manager to revise a plan.
- Worker task context: Explain what a manager should give a worker so its result serves the overall goal without passing along the manager’s entire history.
Why it matters: A clear, bounded assignment lets a worker contribute to the shared goal without needing the manager’s full history. - Worker reports and plan revision: Describe what a worker should report upward when its assignment breaks down, and how the manager should respond when the report challenges a decision or the overall plan.
Why it matters: A return path lets the manager correct a flawed plan without making each worker responsible for overall strategy.
Key terms: overall goal, required interfaces, tool and write boundaries, expected artifact, acceptance checks, upward path, affected decision, evidence, independent reviewer, accountable human
8.5.2 Hierarchical delegation in coding agents
This section shows how coding-agent hierarchies delegate bounded work while keeping integration and permission boundaries with the manager and runtime.
- Manager-Owned Subagent Tasks: Describe how a main coding-agent dialog delegates a bounded task to a subagent while retaining the user's goal and integrating the result. State what the parent must pass to the worker.
Why it matters: A bounded task and a clear expected result let the manager remain accountable for the combined work. - Runtime-Enforced Worker Permissions: Explain why a worker's tool and permission configuration, rather than its role prompt, must bound what it can do.
Why it matters: Enforced permissions keep delegated work within its intended action boundary even if instructions ask for more. - Framework Support Versus Ownership: Distinguish the implementation support supplied by LangGraph and Deep Agents from the hierarchy decisions the application must still make.
Why it matters: Framework features do not replace explicit decisions about accountability in a multi-agent application.
Key terms: main dialog, bounded task, subagent configuration, expected artifact, tool boundaries, runtime, read-only tools, Guardrail Sandwich, LangGraph, Deep Agents
8.5.3 When Hierarchical Delegation breaks
Identifies where hierarchical delegation can fail and how to keep a manager’s plan, worker deliverables, and shared state reliable.
- Manager decomposition risk: Explain why a weak manager plan can misdirect capable workers and how to catch that before costly work proceeds.
Why it matters: Checking the plan early prevents coordinated effort from amplifying a bad direction. - Worker interface alignment: Describe how a worker can complete its assigned task yet harm the larger effort, and how to check for that failure.
Why it matters: A deliverable only helps the larger plan if it works with the other deliverables. - Cascading artifact failure: Trace how a weak artifact can affect dependent tasks and describe the safeguards given here.
Why it matters: Checking an artifact before others depend on it limits the spread of an error. - Hierarchy within larger plans: Explain how hierarchical delegation relates to the other collaboration patterns named here.
Why it matters: Delegation can organize other collaboration patterns rather than compete with them.
Key terms: manager, decomposition, acceptance criteria, local optimization, overall goal, required interfaces, boundary, cascading failure, artifact, shared state
8.6 Testing and observing collaboration
This section explains how to test whether a collaborating team improves task outcomes and how to trace coordination failures without mistaking a trace for proof of correctness.
- Single-agent outcome baseline: Explain why a multi-agent team should be tested on the same task against a credible single-agent baseline, with task outcomes measured before coordination behavior.
Why it matters: It keeps a faster or busier team from being mistaken for a better one. - Pattern-specific coordination seams: Describe what to inspect at the coordination seam for each collaboration pattern: Handoff Chain, Fan-Out/Gather, Adversarial Review, and Hierarchical Delegation.
Why it matters: Looking at the right seam makes a coordination failure visible and actionable. - Trace evidence and limits: Distinguish what a collaboration trace can reveal from what it cannot prove, and describe the additional fields to record for consequential work.
Why it matters: A trace is useful diagnostic evidence, but consequential results also need an auditable basis for acceptance.
Key terms: single-agent baseline, outcome measures, coordination measures, Handoff Chain, Fan-Out/Gather, Adversarial Review, Hierarchical Delegation, MAST, trace, claim
8.7 Composing collaboration patterns
Shows how a code release can combine four collaboration patterns at different stages, with explicit handoffs between them and no pattern added without a need.
- Release collaboration sequence: Trace how the disputed authentication change moves through Hierarchical Delegation, Fan-Out/Gather, Adversarial Review, and Handoff Chain before the manager accepts the release.
Why it matters: Each stage gets a collaboration shape suited to its work without losing ownership of the overall release. - Pattern seam contracts: Describe what must be explicit where the collaboration patterns meet, including worker returns, review decisions, verification handoffs, and final integration.
Why it matters: Explicit seams let the manager tell what was checked, what remains unresolved, and whether the release is ready. - Selective pattern use: Justify using each collaboration pattern only where a stage has a corresponding deficit, rather than applying every pattern to the entire release.
Why it matters: Selective use avoids adding collaboration where it does not address a real problem.
Key terms: Hierarchical Delegation, Fan-Out/Gather, Adversarial Review, Handoff Chain, partition, write-conflict domain, return schema, completion policy, independent evidence, stop rule
8.8 The implementation layers: Where control lives
The section separates where collaboration is implemented from the choice of how agents divide responsibility.
- Collaboration control points: Explain why a collaboration design should start by locating control rather than choosing a framework product. Identify where the plan lives, who dispatches work, where shared state persists, and who accepts the result.
Why it matters: Locating control makes the design choice clearer than starting with a product name. - Implementation layers versus patterns: Distinguish an application's framework, runtime, or harness support from its collaboration pattern, using the Deep Agents example.
Why it matters: Delegation tooling supplies a capability, but the application still has to choose the responsibility split.
Key terms: control point, current plan, shared state, framework, runtime, harness, Deep Agents, collaboration pattern
8.8.1 Three communication channels
Distinguishes three communication channels in agent collaboration and clarifies the human accountability they require.
- Three collaboration communication channels: Distinguish agent-to-agent, human-to-agent, and human-to-human communication by what each carries and why they should be designed separately.
Why it matters: Separating the channels helps ensure that work, human input, and lasting decisions each have a place. - Human accountability without universal approval: Explain why having all three channels requires human ownership, opportunities for risk-based intervention, and durable decision records, but not approval at every agent transition.
Why it matters: It preserves human accountability without making every agent transition wait for approval.
Key terms: agent to agent, human to agent, human to human, RFC, ADR, runbook, accountable human owner, human intervention, durable records
8.8.2 MCP and A2A are the plumbing
This section distinguishes two communication protocols and explains why collaboration architecture must be chosen before protocol plumbing.
- Distinct protocol boundaries: Distinguish Model Context Protocol from Agent2Agent by the communication boundary each serves.
Why it matters: The protocols serve different connections, so the needed connection determines which is relevant. - Architecture before protocol selection: Explain why a collaboration pattern should be chosen before selecting a communication protocol.
Why it matters: Choosing plumbing first cannot settle how the agents should work together.
Key terms: Model Context Protocol, Agent2Agent, tools and data, tasks and results, collaboration pattern, architecture decisions, tool access, task exchange
8.9 Argus checkpoint: Collaboration
This checkpoint describes the collaboration Argus can perform, marks what it cannot yet do, and cautions that coordination does not guarantee a correct plan.
- Distributed review and claim challenge: Describe how Argus distributes one code diff to security, style, and complexity workers, preserves their structured findings at the gather point, and sends a consequential claim through Adversarial Review before the caller accepts it.
Why it matters: This identifies what collaboration the current Argus checkpoint actually implements. - Checkpoint limits and correctness: Distinguish Argus’s current collaboration capabilities from a manager for a multi-stage release plan or a Handoff Chain from acceptance to verification, and explain why coordination alone does not establish plan correctness.
Why it matters: It prevents the reader from mistaking a working review checkpoint for a complete, reliable release workflow.
Key terms: security, style, and complexity workers, structured findings, gather point, Adversarial Review, manager, multi-stage release plan, Handoff Chain, coordination
8.10 Summary
8.11 References
Lists the sources cited in the chapter on agent collaboration.
Where this is used later
- From observed failure to a candidate composition (chapter 10) · Handoff Chain as a collaboration pattern
- What the cases teach us (chapter 11) · Limits on apparent parallelism
- Pattern: Approval Gate (chapter 9) · Separates permission to proceed from finding defects.
- What to observe: Metrics locate the problem; trajectories explain the path (chapter 9) · distinguishing metrics from trajectories when observing system behavior
- The emerging governance ecosystem (chapter 9) · A2A as collaboration plumbing.
Concepts explained in this chapter
- fan-out/gatherA coordination pattern that distributes work across multiple agents or workers and then aggregates their results.
- hierarchical coordinationA collaboration pattern that delegates bounded portions of work to agents arranged hierarchically.
- adversarial thinkingAn adversarial review is a review approach that examines work from a challenging or opposing perspective.
- subagentAn agent assigned a bounded portion of a larger task or delegated plan.
- multi-agent systemA software system in which multiple agents coordinate or work independently to perform tasks.
- collaborationAn agent capability for coordinating information or activity with other agents or humans.
- trajectoryA record of events and operations during a system run, arranged to show its progression and support diagnosis.
- agent harnessA software layer around an agent that manages execution, resources, tools, delegation, context, and verification.
- approval gateA control point that determines whether an operation may proceed autonomously or requires human authorization.
- generator-critic loopA pattern in which a generator produces a candidate result and a critic evaluates it to guide revision or delivery.
- isolationIsolation is a technique for containing the effects of a failure or operation so they do not propagate across system boundaries.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
