Contents
  1. Purpose and foundations
    1. What another agent changes
    2. Coordination foundations
  2. Dividing and assigning work
    1. Decompose for recombination
    2. Roles and decision rights
    3. Coordination structures
  3. Information, state, and handoffs
    1. Send usable results
    2. Accept shared-state changes
    3. Transfer responsibility explicitly
  4. Integration and scrutiny
    1. Check the combined result
    2. Preserve useful independence
  5. Shared resources and limits
    1. Control competing work
    2. Budget the complete team
  6. Failure and diagnosis
    1. Contain failure and unfinished work
    2. Find the consequential exchange
  7. Architectural evidence
    1. Compare complete designs
  8. Check understanding
  9. Open questions
  10. Selected talks
  11. References
  12. Talk library
← All topics

Multi-agent systems

A multi-agent system divides responsibility among agents that can investigate, act or check work separately. The benefit may come from parallel progress, specialized tools or separate working contexts. The challenge is combining their contributions into one useful result: assignments can overlap, assumptions can conflict and local success can leave the overall task unfinished. This chapter explains decomposition, communication, shared state, integration and the costs that determine whether a team improves on one agent.

I — Purpose and foundations

What another agent changes

An agent uses observations to choose its next action toward an assigned goal. In a prescribed workflow, application rules determine the stages and transitions, including branches, repetition, and parallel operations. The distinction is not whether execution responds to new information, but which choices the application leaves to the agent. Agent Engineering develops this distinction. A multi-agent system distributes those choices among several participants, whose decisions must still produce a compatible result.

Coordination manages dependencies among activities: one participant needs another's result, two participants need the same resource, or several contributions must satisfy one requirement. It is the mechanism that keeps locally reasonable decisions compatible with the overall task.

Locate the decision, rather than count calls.
ArrangementWho chooses the work and continuation?
One agent with parallel toolsOne decision-maker selects operations; tools execute them.
Prescribed workflowApplication rules determine stages and transitions, potentially including model calls.
Cooperating agentsSeveral participants select actions within assignments; coordination governs their interaction.

Agents need not use different models or processes. Conversely, separate processes may simply execute predetermined work. A role's instructions, model selection, tool access, and workspace are distinct configuration choices; a specialist name does not create any of them automatically.

Separate participants can investigate different directions or divide information too extensive for one working context—the input available to a model for its current decision. Anthropic's research-system account describes these benefits alongside greater model usage and difficulty with tightly interdependent work. Separation helps only if each participant returns a contribution the others can use; otherwise, it creates more investigation without a better combined result.

Coordination foundations

The central coordination problems predate language models. Systems needed ways to combine partial knowledge, allocate work, and keep participants informed when circumstances changed. The following developments addressed different parts of that problem; they are complementary ideas, not stages in an inevitable replacement sequence.

DevelopmentContribution
Hearsay-II, begun in 1973Carnegie-Mellon's project, described by Erman, Hayes-Roth, Lesser, and Reddy in 1980, combined specialized knowledge sources through shared speech hypotheses. Its configurable structure accommodated interactions that could not all be specified beforehand.
Contract Net, December 1980Reid G. Smith described allocating dynamically generated tasks through announcements, bids, and awards, instead of permanently assigning every task to a processor.
STEAM, September 1997Milind Tambe represented shared team goals and commitments explicitly, supporting role monitoring, reorganization, and decisions about when teammates needed an update.
AutoGen, August 2023Qingyun Wu and colleagues made multi-participant conversation programmable, separating how a participant replies from the control flow choosing who acts next. Participants could combine language models, tools, and human input.

Language models expanded what a participant could interpret and produce through a message interface. They did not make assignment, communication, or shared commitments unnecessary. Those responsibilities still determine whether a collection of capable participants behaves as a coherent system.

II — Dividing and assigning work

Decompose for recombination

Decomposition divides an overall requirement into contributions that can be combined to satisfy it. Start by asking what each assignment needs from the others. The more one assignment depends on or constrains another, the greater their coupling, and the more coordination they require. Assignment size, or granularity, creates a second tradeoff: smaller assignments clarify actions but add decisions and handoffs. The planning chapter explains subgoals; assigning them to separate agents also requires deciding how their results will fit together.

There are different reasons to separate work. Investigators can pursue different evidence, specialists can receive tools suited to their responsibilities, and workers can process large inputs without passing every detail to the coordinator. Medic, a system for diagnosing failing Apache Spark jobs, illustrates the last case: a subagent analyzed charts of job metrics and returned summarized findings to the parent agent. This kept the detailed analysis out of the parent's context. Such separation does not remove dependencies: the parent still needs the findings before using them in its diagnosis.

In this schematic of Medic’s reported metrics-analysis path, the specialist examines chart details and returns selected findings to the parent diagnosis. The parent depends on that contribution without receiving the specialist’s entire analysis; separate contexts are not a security boundary.

Choose boundaries by inspecting prerequisites, shared assumptions, readable inputs, permitted writes, and the final acceptance condition. For example, inspecting a producer and a consumer separately can expose useful parallel work, but their reports must still be checked against the same interface contract. Concurrently changing both sides without preserving that contract creates additional coordination instead.

The testing interface can determine whether useful independent work exists. In Nicholas Carlini's February 2026 compiler-building report, independent failures initially gave parallel agents separable debugging tasks. Linux compilation later concentrated them on the same bottleneck, causing duplicated effort and conflicting changes. The team used the existing GCC compiler for most files and its developing compiler for selected files, making failures easier to localize and divide among agents. This was an experimental project, not a controlled agent-count speedup study.

Roles and decision rights

A role specifies a reusable responsibility. An instance is a participant performing it, and an assignment is the particular work it currently owes. Its deliverable is the result another participant will inspect or consume. These distinctions prevent a broad label such as reviewer from substituting for a concrete promise.

An example read-only review assignment makes both the contribution and its limits explicit.
Contract elementExample
Objective and inputsInspect the named consumer revision against the supplied interface contract.
Dependencies and exclusionsUse the specified producer revision; do not redesign the interface.
Permitted effectsRead source and run checks in the assigned environment; do not publish changes.
DeliverableReturn findings, source locations, check results, and unresolved limitations at the agreed artifact location.
AcceptanceThe integrator checks coverage and compatibility; the worker's completion report does not approve the combined result.

Specialization should change actual instructions, information, capabilities, or assessment duties. In Medic, dedicated prompts and restricted tool subsets made diagnostic responsibilities easier to maintain and test separately. That is a maintenance benefit reported for this system, not proof that every specialized prompt creates expertise.

Keep the acting software, its accountable owner, and the requester it represents distinct. Permission to investigate is not permission to commit a change; delegated authority governs that boundary. Likewise, separate conversations or repository copies are not necessarily execution isolation. A locally useful objective must remain subject to global constraints, such as preserving the public interface.

Coordination structures

Once contributions have boundaries, choose how work is assigned and released. In supervisor–worker delegation, a supervisor requests bounded work and retains orchestration responsibility. A handoff instead transfers responsibility for subsequent work under the application's contract. Either arrangement can use the same underlying model.

Negotiated allocation is useful when the appropriate worker is not fixed beforehand. Contract Net's manager announces eligibility conditions, required bid information, and an expiration. Participants bid; the manager selects a contractor and supplies the information needed to begin. Manager and contractor are task-specific roles, so a contractor can subcontract. Selection still depends on application-defined capability and eligibility rules.

Shared state consists of records accessible to several participants. A blackboard uses shared intermediate results to coordinate further work. In Hearsay-II, changes to hypotheses activated eligible knowledge sources. A contemporary example, ActiveGraph, uses behaviors that react to graph state and emit events; completing research can release a dependent writing task.

Shared state releases dependent work

Example

A dependency can release work through a state change without a direct call from one agent to another.

Research findingsThe result artifact, separate from its completion status.
Research completion recordedShared task state changes.
Dependency condition satisfiedThe relation releases the dependent task.
Writing behavior runsConsumes findings after becoming eligible.
Memo contributionA new result, still subject to the application's acceptance rules.
A simplified ActiveGraph-style dependency: recorded research completion makes writing eligible; it does not guarantee immediate execution. Findings supply the writing input through a separate data path. When writing runs, the produced memo remains subject to result acceptance.
Read the diagram as text
  • Research findings. The result artifact, separate from its completion status.
  • Research completion recorded. Shared task state changes.
  • Dependency condition satisfied. The relation releases the dependent task.
  • Writing behavior runs. Consumes findings after becoming eligible.
  • Memo contribution. A new result, still subject to the application's acceptance rules.
  • Research completion recorded → Dependency condition satisfied: control: completion condition.
  • Dependency condition satisfied → Writing behavior runs: control: enable task.
  • Research findings → Writing behavior runs: data: findings.
  • Writing behavior runs → Memo contribution: data: produced contribution.

Choreography coordinates through published events rather than a central caller: each participant subscribes to relevant events and publishes its own outcomes. This reduces direct coupling but distributes delivery and debugging obligations. A missing result might mean publication failed, consumption failed, or duplicate handling went wrong. Shared-state activation and event choreography can coexist, but neither makes write authority implicit.

Communication structure and authority structure are separate. A central supervisor can leave domain judgments to specialists while owning integration. Conversely, peer messaging still needs rules for resolving dependencies. AutoGen makes a related distinction between participant reply behavior and speaker-selection control. A graph or conversation interface alone does not specify who may accept a result.

III — Information, state, and handoffs

Send usable results

Inter-agent communication is an interface, not an unrestricted conversation. A request asks for work; an observation reports something encountered; a proposal recommends a change; progress describes unfinished work; an accepted decision records what the authorized owner has settled. Treating these as interchangeable text can turn a suggestion into an unintended instruction or a progress update into a completion claim.

Common ground, operationally, is the task-relevant information participants have established for their joint work; it need not mean identical beliefs. Communicate changes that affect another participant's choices. STEAM made this tradeoff explicit: leaving teammates uninformed can damage coordination, but communication itself costs resources. Its selective policy addressed this in symbolic-agent simulations, not language-model teams.

A usable result identifies its assignment, sender, inspected scope, assumptions, findings, supporting artifacts, and unresolved limitations. Provenance records origin and derivation: the inputs used, the activity producing a result, and the responsible participant. The W3C PROV model separates these entities and relationships; a report derived from another report is not another original observation.

Suppose a review message already records its assignment, sender, and the producer and consumer revisions. Its result still needs to say what was established.
Result bodyWhat the recipient can infer
“The consumer is compatible.”The conclusion supplies neither supporting checks nor a coverage limit.
“The consumer accepts the producer's documented success response. Source locations and test output are attached. Error responses were not checked.”The recipient can inspect the support, preserve the qualification, and assign the missing review.

Only information crossing the result boundary is available to the recipient. LangChain's subagent guidance identifies a concrete failure: a worker investigates successfully but omits its findings from the returned response. Forwarding everything is not the only remedy. Select relevant findings, preserve references to detail, and retain qualifications. Context selection and recoverable compaction develop this tradeoff. A schema can require fields without proving their contents true.

Accept shared-state changes

An agent's current context is a local view. A candidate artifact is a proposed contribution. A task record describes obligations and status. An accepted decision governs subsequent work. Keeping all four in one database does not make them equivalent, nor ensure that every participant has read the latest version.

Authoritative state is the application-controlled record used to decide what may happen next. Workers can produce separate contributions while an explicit acceptance boundary controls shared changes. LangGraph's orchestrator-worker example, for instance, gives workers their own state and collects outputs in a shared field. Collection itself is not verification or conflict resolution.

ActiveGraph's proposal path records a target version before application. If two proposals target the same version, applying one makes the other stale. The second needs reconsideration against current state. This applies to the explicit proposal path, not all mutations; freshness checks do not establish semantic correctness or permission.

The object advances; B’s target does not

The object advances; B’s target does notBefore: Object X is version1, proposals A and B each target1. Applying A advances the same object to2; B remains unchanged targeting1, so its mismatch requires reconsideration. B is not automatically wrong or rebased.Before applying AAfter applying AObject X · version 1Object X · version 2Proposal A · target version 1Submitted against Object XProposal A · appliedApplication advanced Object XProposal B · target version 1Retained proposal against Object XProposal B · target version 1Requires reconsiderationApply ARetain B unchangedMismatch: current 2 ≠ B target 1Explicit proposal path only · freshness does not establish permission or semantic correctness
In the explicit proposal path, A and B target Object X version 1. Applying A advances X to version 2; B remains recorded against version 1 and requires reconsideration. This neither automatically rejects B’s meaning nor rebases it.

Read and write ownership should follow these distinctions. A message sends selected information to named recipients. A shared task ledger exposes assignments and accepted status. A blackboard exposes intermediate material that can activate further work. Each needs explicit rules for refreshing readers and accepting writes. An ordered commit boundary can prevent lost updates without serializing every investigation; state acceptance explains the underlying protection.

When an input is superseded, record which contributions depended on it and notify their owners to revalidate. Provenance supplies the relationships, not automatic invalidation. Retained knowledge needs the same care: memory consolidation must not turn repeated copies of a finding into additional support.

Transfer responsibility explicitly

A successful handoff requires agreement about the work that continues, not merely delivery of a message. The recipient needs the current objective, relevant state, permitted actions, deliverable location, outstanding obligations, and a route for clarification or refusal. Use durable task identities and retained artifacts so these obligations survive a worker's lifetime.

Define these events separately in the application contract.
EventEstablished factRemaining obligation
DispatchA request was sent.Ensure receipt or resolve failed delivery.
ReceiptThe recipient received it.Clarify or accept the assignment.
Assignment acceptanceThe recipient undertook the specified work.Perform it or report inability to continue.
Completion reportThe worker reports an outcome.Inspect the result against acceptance criteria.
Result acceptanceThe accepting owner approves the identified contribution.Integrate it and satisfy remaining task requirements.

The FIPA Request protocol distinguishes agreement or refusal from reported success or failure, although explicit agreement is optional in specified circumstances. An operational counterpart is PagerDuty acknowledgment: it records a responder claiming an unresolved incident, while missing acknowledgment permits escalation. Neither precedent makes a completion report independent proof of the requested outcome.

A practical ownership policy keeps the sender responsible while acceptance is pending or refused, assigns execution responsibility after acceptance, and names who owns recovery if the recipient cannot continue. Bind these decisions to the assignment revision. Changed scope should supersede affected assignments rather than silently reinterpret their results. Integration should wait for required accepted contributions; optional work needs an explicit disposition, not an indefinite wait.

Transport does not supply the whole agreement. Direct calls can suffice inside one application. Model Context Protocol (MCP) exposes tools and context; Agent2Agent (A2A) defines remote task exchanges, status, and artifacts. An MCP tool can wrap an agent without thereby acquiring A2A semantics. A framework handoff can also change control state without establishing business acceptance. Choose the integration boundary separately from the responsibility contract; the A2A specification describes its task model.

IV — Integration and scrutiny

Check the combined result

A semantic conflict is an incompatibility in meaning, assumptions, or combined effects. It can exist even when contributions are well formed, current, and individually acceptable. An invariant is a condition the combined result must preserve. Software contracts define such obligations; integration must check them across contribution boundaries.

Sousa, Dillig, and Lahiri's November 2018 Verified Three-Way Program Merge illustrates this with two null-pointer protections. Each branch removes one protection while retaining the other. Combining their edits removes both. SafeMerge checks semantic conflict freedom rather than relying on textual compatibility.

Protection in the published example
VersionEarly null checkGuarded dereference
BasePresentPresent
Branch ARemovedPresent
Branch BPresentRemoved
CombinedRemovedRemoved

The same integration obligation applies to recommendations. Grounded Reasoning Systems for Cloud Architecture separates specialist candidate generation from central reconciliation, then elaborates surviving recommendations. The coordinator looks for conflicts and redundancies before investing in detailed proposals. This is a workflow example, not proof that a coordinating model always resolves them correctly.

Integration should therefore compare assumptions and effects against the shared requirement, not merely concatenate outputs or select the last writer. When requirements themselves disagree, preserve the alternatives and identify the authorized decision-maker. Conflicting code and organizational guidance should remain visible together; silently choosing one can conceal the very issue requiring review. Another fluent summary is not a substitute for that decision.

Preserve useful independence

Correlated mistakes occur together because participants share a misleading source, assumption, model behavior, or influence from another answer. Several agreeing reports can all descend from one mistaken premise. Different role names or models do not establish independent confirmation; the information and checking paths matter.

Independent initial work followed by comparison differs from discussion in which participants revise after seeing one another's answers. In Debate or Vote, majority voting explained much of the gain over one response across seven tested benchmarks and exceeded the tested debate variants on average. More rounds sometimes hurt accuracy. These were mainly answer-generation tasks with a shared underlying model, not shared-state tool workflows. Sampling and agreement explains aggregation separately.

Make the second participant's assessment duty concrete. Eugene Yan and Henna Dattani's May 27, 2026 security-review guide separates vulnerability discovery from adversarial verification. The verifier receives the finding and codebase in a fresh container, without the discoverer's conversation or filesystem, and searches for reasons the finding is wrong, including overlooked mitigations.

The verifier receives the finding and the same code revision, with a different question: what might make the finding wrong? Discovery conversation and working filesystem are excluded from the fresh container. This schematic limits narrative carryover, not shared assumptions or verifier error.

That boundary reduces exposure to the discoverer's narrative; it does not remove shared code, model assumptions, or verifier error. Failure to reproduce an exploit does not prove its absence. Preserve the claim's origin, the check performed, and the check's result. Agreement about what to do remains distinct from correctness of the supporting claims. Checks and their limits develops the latter distinction.

V — Shared resources and limits

Control competing work

Contention is competition for limited access. Two agents can interfere through a mutable file, database record, browser session, or service quota even when their assignments differ. A shared browser is especially concrete: one participant's navigation changes the state the other is observing. Partition resources where possible and coordinate access where sharing is necessary.

Duplicate work repeats an investigation or action. Independent replication can be deliberate scrutiny; accidental repetition wastes capacity. Unique task IDs distinguish records, not semantic scope: two differently named tasks can pursue the same bug. The compiler project used task claims and separate repository clones but still encountered overlapping work and integration conflicts.

Match the control to the boundary.
ProblemUseful controlWhat remains
Overlapping investigationsExplicit scope and task claimsDifferent descriptions can conceal the same work.
Lost shared-state updatesAn ordered commit path for that mutable boundaryParallel reads and investigations can continue.
An obsolete worker writes lateReceiver-enforced ownership generationThe receiver must actually reject obsolete requests.
Repeated external effectsThe receiving service's deduplication contract and outcome reconciliationA task claim or separate workspace does not protect the external operation.

A lease grants temporary permission; expiry does not prove that its holder stopped. Fencing checks an ownership generation where an update is accepted. Chubby uses sequencers to reject obsolete lock-holder requests that arrive late. Apply the same distinction when reassigning agent work: a replacement must not make an old result newly authoritative. Stale-result rejection covers the runtime mechanism.

Deadlock is circular blocked waiting—for example, each of two participants waits for a result the other will produce only afterward. Livelock is continued activity without progress, such as repeatedly revising assignments in response to one another without settling either. Neither is diagnosed merely by slowness or message volume. Identify the missing progress and actual dependency before adding workers or retries.

Budget the complete team

Fan-out launches separate work; fan-in combines the required results. Under fixed durations and represented constraints, the critical path is the longest dependency path determining earliest completion. A required slow contributor delays integration even if every other worker is finished. Shortening work off that path does not necessarily shorten the task.

Consider two independent inspections taking six and four seconds, followed by four seconds of integration and checking. Keep these work durations fixed while varying dispatch overhead and resource availability. Elapsed completion depends on the resulting schedule; summed leaf-operation durations measure something different and are neither token counts nor monetary charges.

Additional resource waits need their own intervals or constraints. If both inspections require one exclusive session, the assumed overlap is infeasible. Do not count prerequisite waiting again inside an operation's duration. Changing concurrency can also change queueing, so yesterday's observed waits are not constants for a new schedule.

Elapsed completion and total work differ

Inspection A takes 6 seconds, B takes 4, and integration takes 4. Only dispatch duration and access to inspection resources change. The serial baseline performs A, then B, then integration.

Elapsed completion: serial 14 s, delegated 12 s (2 s faster).
Summed leaf-operation durations: serial 14 s, delegated 16 s. Parent spans and idle waits add no work here.
Shared-axis schedule comparisonSerial A then B then integration. Delegation dispatches before inspections, which overlap only with independent resources. Integration waits for both results. Dark bars mark operations on the completion critical path; light bar B is noncritical only in the independent case.0481216SerialDelegatedA0–6 sB6–10 sIntegrate10–14 sDispatch0–2 sA2–8 sB2–6 sIntegrate8–12 sSeconds · dark: critical path · light: noncritical inspectionIndependent inspections overlap; integration starts only after the slower A finishes.
OperationStart (s)End (s)Duration (s)Critical?
Dispatch022Yes
A286Yes
B264No
Integrate8124Yes

Default independent resources: serial completion 14 s versus delegated 12 s; leaf durations total 14 s versus 16 s. With the same 2 s dispatch and one exclusive session, delegated completion becomes 16 s. These durations are neither token counts nor monetary charges.

With independent resources and 2 s dispatch, delegation completes in 12 s versus 14 s serially, while summed leaf durations rise to 16 s. An exclusive session removes inspection overlap. The controls change scheduling assumptions, not measured agent performance.

Amdahl's law expresses the fixed-workload limit imposed by unchanged serial work: accelerating only one portion leaves the rest. For agents, delegation may also change investigation depth, communication, and quality, so the law is a useful constraint rather than a universal scaling forecast. Completion-path budgeting treats the timing analysis in more depth.

Allocate the aggregate budget across the delegation tree. Bound concurrency and delegation depth, and reserve capacity for synthesis, checking, and recovery. Giving every child the parent's entire allowance multiplies exposure rather than preserving the limit. Repeated summaries and unnecessary exchanges belong in the consumption ledger alongside useful investigation.

Pydantic AI documents passing a parent's usage object into delegated runs for aggregate accounting. Its Temporal-activity exception matters: a copied context does not propagate delegated usage back that way. Across different models, aggregate tokens also do not reconstruct price. Keep requests, tokens, priced usage, elapsed time, and human review effort separate.

VI — Failure and diagnosis

Contain failure and unfinished work

Failure containment limits which assignments, artifacts, resources, and decisions a failure can affect. A crash leaves execution unfinished; an incorrect contribution threatens dependent conclusions; a blocked dependency prevents useful continuation; a common failure can affect every participant. Separate proposal areas and validation before shared publication keep a worker's output from automatically becoming the team's accepted state.

Logical roles are not containment barriers. Enforce tool permissions and execution isolation at the actual resource boundary. Then use recorded dependencies to select repair scope: preserve unrelated accepted work, but revalidate conclusions that relied on an invalid contribution. Lineage identifies candidates for repair; the application must decide whether they remain valid.

Repair follows dependencies

Example

One invalid contribution can block integration without invalidating unrelated accepted work.

Finding A — invalidIts owner must correct or withdraw the contribution.
Recommendation A — recheckDepends on the invalid finding; its owner must reassess it.
Finding B — acceptedDoes not depend on finding A.
Contribution B — retainedRemains usable under the unchanged assumptions.
Final integration — blockedIntegrator owns repair coordination and any decision to return permitted partial work.
An invalid finding identifies its derived recommendation for reassessment; lineage does not by itself prove that recommendation false. The unrelated accepted contribution remains usable under unchanged assumptions. Final integration waits for the required unresolved contribution; the integrator owns repair and any permitted partial outcome.
Read the diagram as text
  • Finding A — invalid. Its owner must correct or withdraw the contribution.
  • Recommendation A — recheck. Depends on the invalid finding; its owner must reassess it.
  • Finding B — accepted. Does not depend on finding A.
  • Contribution B — retained. Remains usable under the unchanged assumptions.
  • Final integration — blocked. Integrator owns repair coordination and any decision to return permitted partial work.
  • Finding A — invalid → Recommendation A — recheck: support dependency: invalidated.
  • Finding B — accepted → Contribution B — retained: support dependency: unchanged.
  • Recommendation A — recheck → Final integration — blocked: required contribution: unresolved.
  • Contribution B — retained → Final integration — blocked: required contribution: available.
Sibling-failure policy is a task decision.
PolicyAppropriate conditionCompletion obligation
Fail fastA failed prerequisite makes remaining work unusable.Request cancellation and account for every child.
Collect independent outcomesUnaffected contributions remain useful.Record successes and failures separately.
Return partial workThe task contract permits a useful incomplete result.Name missing coverage and remaining ownership.

Python 3.11's TaskGroup and gather illustrate different local policies: TaskGroup cancels siblings after a non-cancellation exception; gather normally lets them continue, and can collect exceptions alongside results. These semantics do not detect plausible wrong answers or provide durable distributed ownership.

Structured concurrency ties child lifetimes to an owning scope. Across worker or coordinator loss, retained assignments still need a named recovery owner. Deliberately detached work needs its own owner and control handle. Cancellation scope must be explicit: Pydantic AI distinguishes a delegate cancelling itself from a shared token cancelling a run tree.

A stop request is not proof that remote execution ended. Temporal documents cooperative cancellation and timed-out attempts that may continue while another attempt runs. Preserve uncertain external outcomes and reconcile them before repeating consequential actions; effect recovery owns that mechanism. A deadline can end the current attempt without making missing required work complete.

Find the consequential exchange

A trace correlates operations in an execution; a span records one operation. Observability explains those primitives and their propagation. Multi-agent diagnosis additionally needs to reconstruct what one participant made available, what another actually received, and which contribution the system accepted.

Record meaning-changing boundaries, not just separate transcripts.
Boundary recordDiagnostic use
Actor, assignment, revision, and ownerDetermine what was owed and who remains responsible.
Input and artifact versionsDistinguish stale evidence from a current but mistaken interpretation.
Sent, received, and consumed result referencesSeparate omitted transmission from unused available information.
Acceptance and shared-resource operationsIdentify where a proposal became consequential.
Terminal outcome and unfinished obligationsDistinguish completion from abandonment or unresolved waiting.

Lamport's ordering of distributed events gives a useful constraint: sending a message precedes its receipt, and these relationships compose with local event order. Nearby timestamps alone do not show that information crossed a boundary. Even a recorded receipt establishes possible influence, not that the model understood or used the message.

In the reported pharmaceutical analytics failure, attribution identified reduced insurance coverage and patient affordability as causes of declining prescriptions. The later recommendation emphasized sales-representative activity instead, then forecast improvement from that intervention. The observed problem was a broken connection between cause and action. The speakers attributed it to their decomposition; the example alone does not isolate architecture from model capability.

The repair depends on where the connection failed. Missing evidence calls for investigation; a finding omitted from transmission calls for a better result contract; received information ignored during synthesis calls for different synthesis constraints; an incoherent recommendation accepted afterward calls for a stronger final check. Why Do Multi-Agent LLM Systems Fail? documents lost context, ignored inputs, missing clarification, and inadequate verification as distinct observed failures. Such labels organize diagnosis; controlled changes test its explanation.

Locate the break before choosing the repair

Locate the break before choosing the repairFive distinct records: finding, sent result, received input, candidate and accepted outcome. Missing established findings concern investigation; omitted findings concern packaging; ignored received findings concern synthesis; accepted incoherence concerns final checking. Missing records leave events unknown.Finding artifactEstablished contentSent resultPackaged contentReceived inputAvailable contentCandidateRecommendationAccepted outcomeSelected by ownerInvestigatePackageDeliverSynthesizeAcceptMissing findingsInvestigate scopeFinding omittedRepair result contractReceived but ignoredConstrain synthesisIncoherence acceptedStrengthen final checkMissing records → unknown event, not proof of no communication. Receipt does not prove use.
This diagnostic framework is not a reconstruction of the pharmaceutical system’s unavailable trace. Arrows denote information packaging, transfer, synthesis or acceptance, not proof of understanding. Investigate the recorded boundary before attributing the failure.

VII — Architectural evidence

Compare complete designs

Compare a capable single agent, a prescribed workflow with useful parallel operations, and the proposed cooperating team. A paired comparison evaluates alternatives on the same tasks. Restore each starting environment, repeat trials to expose variability, and inspect the final artifact or environment outcome rather than accepting the system's own completion claim.

Declare the experiment before interpreting its outcome.
DimensionComparison requirement
Task familiesInclude separable investigations and tightly coupled changes; report them separately.
Available meansDeclare model access, inputs, tools, permissions, and human assistance.
ResourcesDistinguish equal allowances from equal realized tokens, cost, or time.
Useful outcomeCheck final quality, required coverage, and consequential failures.
Coordination burdenCount duplicated work, integration, review, waiting, and recovery.
Disrupted executionInclude late, conflicting, and incomplete contributions with explicit expected dispositions.

An equal-resource experiment asks which architecture uses a stated allowance better. A practical comparison asks which design meets a quality requirement and deadline at acceptable cost. These are different claims. Towards a Science of Scaling Agent Systems found task-dependent results: separable financial investigations benefited, while all tested multi-agent variants underperformed the single-agent baseline on sequential inventory-changing planning. Matching maximum total iterations did not equate realized tokens, prices, or latency.

An architectural ablation removes or changes one mechanism to test its contribution. Remove peer discussion while retaining independent work; replace dynamic assignments with prescribed ones where feasible; change context separation without silently increasing resources. The debate-versus-voting result makes communication removal an informative test, not a universal recommendation to suppress communication.

Keep a boundary when focused responsibility, separate information, or useful parallel progress improves the complete outcome enough to repay coordination. Simplify it when prescribed work delivers the same benefit with less uncertainty. Remove it when repeated explanation, conflicting contributions, or recovery dominates. Victor Dibia's eval-driven design guidance captures the practical discipline: establish a working baseline, then add agent complexity only when task-specific evaluation supports it.

Open questions

  1. Predicting useful decomposition remains difficult because task coupling can emerge during execution. Progress would mean recognizing when independent work has become a shared bottleneck and revising assignments without losing useful progress.

  2. Selective communication must preserve consequential changes without consuming the benefit of delegation. Useful progress would demonstrate task-specific policies that reduce exchanges while retaining coordination under unexpected conditions.

  3. Semantic integration is harder than version checking: current, individually valid proposals can still conflict. Progress would connect executable shared requirements to acceptance checks that detect incompatible combined effects without rejecting useful alternatives.

  4. Measuring the value of agent boundaries requires separating decomposition from extra computation and human repair. Stronger comparisons would include credible single-agent and prescribed-workflow baselines, matched operating conditions, and measured integration and recovery effort.

Follow the curated reading path through the speakers and demonstrations behind this entry.

Explore more talks

The rest of the library, beyond the curated path. Cited talks support this entry; reviewed transcripts were processed in full. Metadata candidates have not been reviewed as sources or verified as topic members.

51 matching talks

TalkSpeakerEventYear
Sarmad QadriAI Engineer World's Fair 20252025
Tom SmokerAI Engineer World's Fair 20252025
Eno ReyesAI Engineer World's Fair 20242024
Agents need more than a chat

Transcript reviewed

Jacob LauritzenAI Engineer Europe 20262026
Nick Nisi, Zack ProserAI Engineer World's Fair 20252025
Marah Abdin, Robert McHardyAI Engineer World's Fair 20262026
Maxime Rivest, Isaac MillerAI Engineer World's Fair 20262026
Charles PackerAI Engineer Summit 20252025
Yohei NakajimaAI Engineer World's Fair 20262026
Allie Howe, Dex Horthy, Geoffrey Huntley, Ian Livingstone, Greg PstruchaAI Engineer World's Fair 20262026
Ilan BigioAI Engineer Summit 20252025
Anoop Kotha, Toki SherbakovAI Engineer World's Fair 20252025
Vinoth GovindarajanAI Engineer World's Fair 20262026
Vision: Zero Bugs

Cited in this entry

Johann Schleier-SmithAI Engineer Code 20252025
Lance MartinAI Engineer World's Fair 20262026
Eugene YanAI Engineer World's Fair 20262026
Juan PeredoAI Engineer Summit 20252025
DottaAI Engineer World's Fair 20262026
Nishant GuptaAI Engineer World's Fair 20262026
Adam TerlsonAI Engineer Summit 20252025
Sarthak AggarwalAI Engineer World's Fair 20262026
Vincent KocAI Engineer Europe 20262026
Tom MoorAI Engineer World's Fair 20252025
Damien MurphyAI Engineer World's Fair 20252025
Daniel ChalefAI Engineer World's Fair 20262026
Alex GavrilescuAI Engineer Code 20252025
Brandon WaselnukAI Engineer Europe 20262026
Aparna Dhinkaran, Aparna DhinakaranAI Engineer Summit 20252025
Anekha SokhalEvent unknownUnknown
Will BrykAI Engineer World's Fair 20262026
Dan Barrett, Raymond Weitekamp, Jose Montes de OcaEvent unknownUnknown
Noyan TokgozogluEvent unknownUnknown
Max DrakeEvent unknownUnknown
Cole GannawayEvent unknownUnknown
Vlad LuzinAI Engineer World's Fair 20262026
Jack WotherspoonEvent unknownUnknown
SallyAnn DeLuciaEvent unknownUnknown
Will Bond, Ameya KetkarAI Engineer World's Fair 20262026
Jean-Denis GrezeEvent unknownUnknown
Justin JoyceAI Engineer World's Fair 20262026
The Highest Loop — swyx

Metadata candidate

Shawn "swyx" WangAI Engineer World's Fair 20262026
CJ Avilla, Harrison StallEvent unknownUnknown
Tim TylerEvent unknownUnknown
James ZouAI Engineer World's Fair 20262026
Jediah KatzEvent unknownUnknown
Abduallah MohamedAI Engineer World's Fair 20262026
Ido SalomonAI Engineer World's Fair 20262026
Fuad AliEvent unknownUnknown
Aman SinghEvent unknownUnknown
Karthik Ranganathan, Heather DowningAI Engineer World's Fair 20262026
Aditya GautamAI Engineer World's Fair 20262026

References

Coverage and source review
Processed transcripts
33 processed in full · 5 in the curated path
Automated source review
Passed
Metadata candidates
23 unreviewed; not verified topic membership
Corpus version
1bd8e407b26a07b33815594e1b2db5f41827119a2b3cb6fbf240f9fc571fc767

Automated review checks source support; it is not publication approval.

A synthesis of selected conference talks and technical references. Citations link to the source material; they do not imply that every talk on this subject is included.

  1. Building Effective Agents

    https://www.anthropic.com/engineering/building-effective-agents

  2. The Interdisciplinary Study of Coordination

    https://crowston.syr.edu/sites/default/files/acmcs94.pdf

  3. Claude Code: Create Custom Subagents

    https://code.claude.com/docs/en/sub-agents

  4. How we built our multi-agent research system

    https://www.anthropic.com/engineering/multi-agent-research-system

  5. The Hearsay-II Speech-Understanding System: Integrating Knowledge to Resolve Uncertainty

    https://mas.cs.umass.edu/Documents/Erman_Hearsay80.pdf

  6. The Contract Net Protocol: High-Level Communication and Control in a Distributed Problem Solver

    https://www.reidgsmith.com/The_Contract_Net_Protocol_Dec-1980.pdf

  7. Towards Flexible Teamwork

    https://arxiv.org/pdf/cs/9709101

  8. AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation

    https://arxiv.org/html/2308.08155v2

  9. Building Reliable Agentic Systems

    https://www.youtube.com/watch?v=bjNYEc908oQ&t=245

  10. Medic for Apache Spark - First Aid for Failing Jobs - Drasko Profirovic, Pinterest

    https://www.youtube.com/watch?v=0RNNfxpdbQk&t=429

  11. Medic for Apache Spark - First Aid for Failing Jobs - Drasko Profirovic, Pinterest

    https://www.youtube.com/watch?v=0RNNfxpdbQk&t=507

  12. Verified Three-Way Program Merge

    https://www.cs.utexas.edu/~isil/verified-merge.pdf

  13. Building a C compiler with a team of parallel Claudes

    https://www.anthropic.com/engineering/building-c-compiler

  14. How we built our multi-agent research system

    https://www.anthropic.com/engineering/multi-agent-research-system

  15. Backlog.md: Terminal Kanban Board for Managing Tasks with AI Agents — Alex Gavrilescu, Funstage

    https://www.youtube.com/watch?v=zMXKhhwiCIc&t=237

  16. IT Admin for the AI Workforce — Sarthak Aggarwal, Decawork

    https://www.youtube.com/watch?v=q-WOjZhOMCA&t=151

  17. LangChain: Subagents

    https://docs.langchain.com/oss/python/langchain/multi-agent/subagents

  18. LangChain: Handoffs

    https://docs.langchain.com/oss/python/langchain/multi-agent/handoffs

  19. The Hearsay-II Speech-Understanding System: Integrating Knowledge to Resolve Uncertainty

    https://mas.cs.umass.edu/Documents/Erman_Hearsay80.pdf

  20. Active Graph Agent Runtime (BabyAGI 4)

    https://www.youtube.com/watch?v=khVX_BUnEwU&t=189

  21. From Chaos to Choreography: Multi-Agent Orchestration Patterns That Actually Work — Sandipan Bhaumik

    https://www.youtube.com/watch?v=2czYyrTzILg&t=406

  22. Grounded Reasoning Systems for Cloud Architecture

    https://www.youtube.com/watch?v=9mzfioh1Zag&t=912

  23. FIPA Request Interaction Protocol Specification

    https://www.fipa.org/specs/fipa00026/SC00026H.html

  24. ActiveGraph: Patches

    https://github.com/yoheinakajima/activegraph/blob/main/docs/concepts/patches.md

  25. W3C PROV Model Primer

    https://www.w3.org/TR/prov-primer/

  26. Grounded Reasoning Systems for Cloud Architecture

    https://www.youtube.com/watch?v=9mzfioh1Zag&t=661

  27. Citation Needed: Provenance for LLM-Built Knowledge Graphs

    https://www.youtube.com/watch?v=H7puB0RwJMM&t=20

  28. Effective context engineering for AI agents

    https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents

  29. LangGraph: Workflows and Agents

    https://docs.langchain.com/oss/python/langgraph/workflows-agents

  30. From Chaos to Choreography: Multi-Agent Orchestration Patterns That Actually Work — Sandipan Bhaumik

    https://www.youtube.com/watch?v=2czYyrTzILg&t=716

  31. Your Agent Didn’t Fail. Your Harness Did.

    https://www.youtube.com/watch?v=BInpv7lGp1o&t=508

  32. Backlog.md: Terminal Kanban Board for Managing Tasks with AI Agents — Alex Gavrilescu, Funstage

    https://www.youtube.com/watch?v=zMXKhhwiCIc&t=13

  33. PagerDuty: Incidents

    https://support.pagerduty.com/main/docs/incidents

  34. Python 3.11: Coroutines and Tasks

    https://docs.python.org/3.11/library/asyncio-task.html

  35. A2A & MCP: Automating Business Processes with LLMs

    https://www.youtube.com/watch?v=wXVvfFMTyzY&t=456

  36. A2A specification: task delegation and relationship to MCP

    https://a2a-protocol.org/latest/specification/

  37. Stop babysitting your agents: building a context engine for mergeable code

    https://www.youtube.com/watch?v=BiG2ssibKGc&t=558

  38. Vision: Zero Bugs

    https://www.youtube.com/watch?v=qLqttdO33UM&t=1616

  39. Debate or Vote: Which Yields Better Decisions in Multi-Agent Large Language Models?

    https://arxiv.org/html/2508.17536v1

  40. Using LLMs to secure source code

    https://claude.com/blog/using-llms-to-secure-source-code

  41. The Chubby Lock Service for Loosely-Coupled Distributed Systems

    https://research.google.com/archive/chubby-osdi06.pdf

  42. Temporal Activity Definition

    https://docs.temporal.io/activity-definition

  43. Oracle Java Tutorials: Deadlock

    https://docs.oracle.com/javase/tutorial/essential/concurrency/deadlock.html

  44. Oracle Java Tutorials: Starvation and Livelock

    https://docs.oracle.com/javase/tutorial/essential/concurrency/starvelive.html

  45. Kelley and Walker: Critical-Path Planning and Scheduling

    https://mosaicprojects.com.au/PDF/PM-History_Critical_Path_Planning_&_Scheduling_Kelley_and_Walker_1959.pdf

  46. Project Management for Construction: Fundamental Scheduling Procedures

    https://www.cmu.edu/cee/projects/PMbook/10_Fundamental_Scheduling_Procedures.html

  47. CUDA C++ Best Practices Guide

    https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html

  48. Pydantic AI: Multi-agent Applications

    https://pydantic.dev/docs/ai/guides/multi-agent-applications/

  49. Lessons from building GenAI based applications — Juan Peredo

    https://www.youtube.com/watch?v=YYcNm2RexnY&t=1416

  50. Building the platform for agent coordination

    https://www.youtube.com/watch?v=UG9IAdmi2Dg&t=1138

  51. Production Evals For Agentic AI Systems

    https://www.youtube.com/watch?v=vljxQZfJ9wY&t=163

  52. Why Do Multi-Agent LLM Systems Fail?

    https://arxiv.org/html/2503.13657v3

  53. Your Agent Didn’t Fail. Your Harness Did.

    https://www.youtube.com/watch?v=BInpv7lGp1o&t=608

  54. Temporal Activity Execution

    https://docs.temporal.io/activity-execution

  55. From Chaos to Choreography: Multi-Agent Orchestration Patterns That Actually Work — Sandipan Bhaumik

    https://www.youtube.com/watch?v=2czYyrTzILg&t=1323

  56. Ensure AI Agents Work: Evaluation Frameworks for Scaling Success

    https://www.youtube.com/watch?v=OC04sP_QgTI&t=855

  57. Time, Clocks, and the Ordering of Events in a Distributed System

    https://lamport.azurewebsites.net/pubs/time-clocks.pdf

  58. Why We Killed Our Multi-Agent Pipeline — Subbiah Sethuraman and Abhilash Asokan, ZS Associates

    https://www.youtube.com/watch?v=u6jJcIFDLE4&t=254

  59. Demystifying evals for AI agents

    https://www.anthropic.com/engineering/demystifying-evals-for-ai-agents

  60. Towards a Science of Scaling Agent Systems

    https://arxiv.org/html/2512.08296v1

  61. UX Design Principles for (Semi) Autonomous Multi-Agent Systems

    https://www.youtube.com/watch?v=fmZWvE7yDZo&t=661

  62. UX Design Principles for (Semi) Autonomous Multi-Agent Systems

    https://www.youtube.com/watch?v=fmZWvE7yDZo&t=409

  63. Stop babysitting your agents: building a context engine for mergeable code

    https://www.youtube.com/watch?v=BiG2ssibKGc&t=785

  64. UX Design Principles for (Semi) Autonomous Multi-Agent Systems

    https://www.youtube.com/watch?v=fmZWvE7yDZo&t=884

  65. Grounded Reasoning Systems for Cloud Architecture

    https://www.youtube.com/watch?v=9mzfioh1Zag&t=1091