Multi-Agent Systems

Coordination and the alternatives

Coordination manages dependencies among activities and the participants responsible for them. Dependencies include needing another activity’s output and competing for a limited resource. This coordination framework directs attention toward the work that must fit together, rather than the number of agents. [1]

An agent delegates meaningful next-action choices to a model. A prescribed workflow can also invoke models, branch, and run concurrently. Multiple calls therefore do not establish multiple agents. Agent Engineering develops this distinction; here it determines who can discover, assign, and revise investigative work. [2]

A constructed API-review fixture makes the alternatives concrete. Contract C1 requires an integer owner_id; proposed contract C2 permits null. Billing and reporting consume that field. The requested artifact is a compatibility report covering both consumers, their inspected revisions, supporting checks, and unresolved conditions. All investigations are read-only; producing the report does not authorize deployment. [3]

Separate contexts can support broader investigation and specialized access. The gains shrink when participants repeatedly need one another’s evolving conclusions. Launching workers, transferring context, duplicating searches, and synthesizing results all consume resources. A useful baseline therefore includes a capable single agent and prescribed parallel work, not merely a weak single response. [5]

Task boundaries and bounded roles

Decomposition turns the requested outcome into intermediate deliverables and dependencies. Coupling describes how strongly one participant’s decisions depend on another’s findings or changes. Consumer-based inspections offer clearer boundaries than an instruction to help investigate: each produces a named finding that the integrator can inspect. [1][6]

Useful granularity balances local clarity against coordination burden. Smaller tasks narrow the available actions but create more decisions and handoffs. A worker assigned only to locate one obvious field may cost more to brief than to replace with a tool call. Constantly changing shared assumptions also force repeated revisions across otherwise separate assignments. [7]

Partitioning billing and reporting divides different work. Assigning two reviewers to billing deliberately repeats work to obtain complementary checks. The latter needs a reconciliation plan and consumes additional effort even when both reviewers succeed. Neither arrangement removes the obligation to integrate the complete review. [8]

Context is the information supplied to the model for its next decision; Context Engineering explains its assembly. Specialized roles can receive different evidence and tools while using the same model. Medic illustrates this separation with dedicated diagnostic prompts and restricted tool subsets, including a metrics-analysis subagent that returns compact findings. [9][10]

Participant identity identifies who executed; role identifies the assignment; model identity identifies the predictor; workspace identifies accessible files. These are separate dimensions in subagent configuration. A role name creates neither expertise nor isolation. Enforce permitted actions through bounded autonomy, rather than trusting the role description. [11]

Coordination patterns and decision placement

A blackboard is a common collection of intermediate hypotheses or results. In Hearsay-II, condition-action modules become eligible when records change. Sharing a database alone supplies neither activation rules nor stopping criteria. [15]

Centralized assignment concentrates routing and integration at a supervisor. A potential architectural bottleneck follows: workers may wait for its decisions. Peer clarification moves some decisions between workers but still needs a recipient for unresolved conflicts. Fixed routing suits known dependencies; input-dependent decomposition lets a coordinator discover and assign work during inspection. [16][2]

Synchronous delegation waits for a reply before continuing dependent work. Asynchronous delegation permits other work to continue while a result is pending. A delivery receipt establishes neither an answer nor a satisfied prerequisite. Waiting is appropriate when the next action requires the reply; independent branches need not stop. [17]

Background execution also needs completion delivery and interaction rules. Results can arrive while the user changes the request. One local coordination pattern queues user messages and returned results for a single conversation processor while independent investigations run concurrently. That ordering does not by itself provide distributed durability or crash recovery. [18][4]

Messages that preserve intent and evidence

An assignment requests work; a clarification request identifies missing information; an observation reports evidence; a proposal recommends an action; an accepted result has passed the application’s admission criteria. Treating these as interchangeable text allows an untested proposal to become an apparent fact. [19]

The worker’s investigation and its returned message are different artifacts. A wrapper may return only a final summary even when the worker inspected decisive evidence. Preserve the actual conditions of the finding: billing B7 rejects null under C2 is narrower than billing is incompatible. [13]

Selective communication sends what the recipient needs, with references for deeper inspection. Summaries should preserve exceptions, unresolved obligations, and evidence links. Output contracts help validate required fields; evidence records preserve meaning. A valid shape cannot establish that the test supports the conclusion. [21]

Provenance connects evidence, transformations, outputs, and responsible participants. The PROV primer distinguishes the records used from the activities producing new records. These relationships make a claim inspectable; they do not certify its truth. [22]

Private views and shared authoritative state

Shared state is information multiple participants can read or update. Sharing access does not establish authority. A conversation may contain an outdated finding, while the task record requires C2 and the source repository contains a newer consumer revision. Name which system controls each fact before deciding which representation to trust. [23]

Immutable findings preserve the inputs and outputs of an investigation. Append a new version instead of overwriting a previous result. This supports inspection and recovery, but concurrent submissions still need admission rules. A history of versions does not automatically identify the current owner or determine which findings remain applicable. [26]

For this review, changing the required contract from C1 to C2 removes C1-only findings from current acceptance until their applicability is checked. Historical evidence remains inspectable. The change affects dependent conclusions, not necessarily every stored result. Dependent context rebuilding explains how revised source information affects later model inputs. [21]

Read access, contribution rights, and permission to revise accepted records are separate. Shared memory can enable reuse while also exposing information across participants. Memory identity and scope and authoritative execution records supply the underlying boundaries; a shared namespace or readable file does not enforce them. [27]

Accepted handoffs and changing ownership

A handoff transfers responsibility through acceptance by the recipient or runtime. Sending, receiving, accepting, performing, and completing are distinct events. FIPA’s request protocol separates acceptance from outcome reporting. [28]

Framework terminology can be narrower. A runtime handoff may switch the active prompt and tools through control state. Nested delegation instead calls a specialist and returns to the caller. Neither label alone defines who remains accountable when the recipient refuses or never responds. [29][30]

The fixture uses an explicit policy: the dispatcher remains accountable while acceptance is pending or rejected. Conditional acceptance establishes one execution owner. Expiry returns scheduling responsibility to the dispatcher; reassignment advances the ownership generation. An operational analogue is incident acknowledgment: requesting attention, claiming responsibility, and resolving the issue remain separate. [31]

A lease grants time-limited ownership; Scheduling and ownership explains conditional claims. Expiry does not stop the old worker. Fencing rejects obsolete ownership generations at the receiving boundary, as illustrated by Chubby sequencers. [32]

Keep identities separate: the task survives reassignment; the participant names the worker; the attempt names one execution; a message identifies an exchange; the input revision identifies inspected material; the ownership generation identifies current authority. Combining these into one run identifier makes late-result decisions ambiguous. [33]

Contention, duplicate work, and conflicting updates

Contention is competition for a shared resource or update opportunity. Two investigators may compete for a rate-limited service or both try to replace the accepted billing finding. Resource allocation and record admission address different dependencies. [1]

If two workers read the same record and save independent replacements, the later save can erase the earlier result. An ordered commit path protects that mutation boundary while allowing investigations to run concurrently. Separate immutable submissions additionally preserve both proposals for inspection. [34]

Optimistic concurrency control accepts an update only if the expected record revision still matches. Version-aware HTTP updates provide a concrete example. For result admission, perform the required checks and accepted-pointer update atomically; otherwise another writer can change the record between validation and commit. [37]

These checks reject mechanical conflicts. They cannot establish whether two differently worded claims mean the same thing. Likewise, preventing duplicate computation differs from idempotency, which prevents additional effects from repeated attempts. Recorded intent and external effects explains why enforcement must reach the service performing the action. [38][36]

Integration and evidential disagreement

Integration establishes whether the contributions jointly answer the task. Concatenation can preserve every sentence while losing the relationship between cause and recommendation. In a presented analytics failure, agents identified reduced insurance coverage and patient affordability but recommended more sales-representative activity. The intervention did not address the stated cause. [39]

In the API fixture, billing B7 rejecting null and reporting R4 tolerating null are compatible findings about different consumers. Two billing conclusions based on C1 and C2 are also not directly comparable. Only after scope, revisions, configuration, and tested conditions align does disagreement require adjudicating competing claims about the same behavior. [40]

A separate verifier context can focus on a rubric rather than inherit the entire construction conversation. Give it the artifact and evidence needed to challenge the result. Oracles and judgments explains criterion design. Separate context is useful separation of work, not proof of independent errors or a correct verifier. [41]

Correlated errors share causes: common evidence, instructions, models, or an early answer can steer several participants toward the same mistake. Agreement is therefore not independent confirmation. In an answer-generation study, majority voting outperformed the tested debate variants on average; additional discussion sometimes reduced accuracy. Those results do not establish the best policy for tool-using workflows. [42]

Targeted verification should resolve the disputed behavior directly. For a code change, useful layers include reproducing the original failure, checking regressions, and having a fresh investigator probe related failure paths. Rework ends when acceptance is supported or its allocated effort is exhausted; unresolved disagreement remains an output rather than disappearing during synthesis. [43]

Collective work, latency, and resource limits

Elapsed latency measures time to the accepted result. Aggregate work sums participating operations, including overlapping ones. The critical path is the dependency chain limiting earliest completion under the represented constraints. Accelerating another branch may leave completion unchanged. Latency budgets and dependency paths explains this distinction. [44]

A shared rate limit can serialize branches that have no information dependency. Represent that wait or resource ordering explicitly; do not add prerequisite waiting again inside a branch duration. Changing concurrency can also change queueing, so an observed wait is not a fixed constant for predicting a new schedule. [45]

Amdahl’s law describes a fixed-workload limit: unchanged serial work bounds the benefit of accelerating parallel work. Agent decomposition can change the workload itself by adding investigations, communication, and checking. A shorter schedule can therefore coexist with more total work, different coverage, and a different result. [48]

Bounded concurrency limits simultaneous work. Child agents consume the parent task’s allowances rather than receiving fresh unlimited budgets. Account for pending requests as well as completed usage before launching more branches. Budgets across concurrency and restart supplies the admission machinery; delegation changes who spends the allowance, not its scope. [49]

Progress and group termination

Liveness concerns the ability to make progress. Progress should advance a required deliverable, resolve a blocker, or establish a terminal outcome. Messages, repeated assignments, and additional agents can increase activity without advancing any of these. Limits on delegation depth, active participants, communication rounds, and total duration need enforcement across the group. [50]

Deadlock requires mutual blocked waiting; a slow worker alone is insufficient. Livelock and starvation distinguish unproductive responses from persistent resource exclusion. Recovery must address the actual dependency rather than merely increase the message limit. [51][52]

A join policy states what the group waits for. An all-required review cannot claim completeness while billing is missing. A permitted partial report can retain reporting’s evidence while labeling billing unresolved. Exhausted effort or unavailable judgment can instead trigger escalation. A watchdog can detect stalled progress; it does not establish the correctness of completed work. [50][53]

Group stop, cancellation requested, and termination observed are separate states. Durable stopping prevents new dispatch and preserves unresolved work. Remote handlers must cooperate with cancellation, and a request can finish before cancellation arrives. Ending the supervisor does not establish that descendants stopped consuming resources. [54]

Failure containment and selective recovery

A containment boundary limits which records, actions, and downstream decisions a participant can affect. Give investigators their own submission areas and admit results through controlled checks. Different prompts do not provide process or filesystem isolation; Sandboxes and Execution Isolation explains those runtime boundaries. [11]

The proposed API-review policy preserves a valid reporting finding while billing undergoes targeted revalidation. If the common contract itself was wrong, both branches may require renewed checks. Recovery follows evidence dependencies, not merely the list of workers that returned an error. [57]

Fail-fast and collect-all are different policies. Python’s TaskGroup cancels siblings after a member’s non-cancellation exception; gather can leave siblings running or collect failures with results. These local semantics illustrate the choice, not a durable distributed guarantee. Cancellation also cannot reverse external effects or detect a plausible false finding. [55]

A circuit breaker temporarily rejects calls after repeated service failures, then probes for recovery. It can reduce cascading timeouts but cannot determine whether an answer is supported. Bounded retries govern repeated attempts; the group still decides whether to continue, return qualified partial work, or escalate. [60]

Reconstructing interactions and responsibility

A trace connects execution records; spans and concurrency describe timing and parentage, while identity across attempts connects interrupted work. Investigation needs the messages actually supplied, returned decisions, state transitions, and artifact references. It does not require treating private model reasoning as observable evidence. [61]

Happened-before combines order within a process, message send-before-receive, and transitivity. Overlapping timestamps establish no information transfer. Distinguish arrival from application processing: receipt alone does not show that a finding entered the integrator’s context or influenced its report. [62]

If the admission event is absent, the cause remains unresolved: acceptance may have bypassed checks, the report may have read another store, or telemetry may be incomplete. Obtain the accepted-result record and the report’s actual inputs before blaming worker reasoning. Execution parentage also does not identify who accepted responsibility. [61]

Evidence for retaining or simplifying coordination

Compare the capable single agent, prescribed concurrent workflow, and coordinating agents on matched tasks with separately initialized state. Hold evidence access, tools, acceptance criteria, model choices, and resource allowances explicit. Repeat trials because outcomes vary. Controlled offline comparisons permit different trajectories while preserving a meaningful comparison. [63]

An ablation removes a role or communication mechanism while preserving the other relevant conditions. Compare independent checks with checks that exchange answers to separate aggregation from discussion. Fault injection deliberately interrupts execution to test a promised behavior. Neither a successful demonstration nor an attractive architecture diagram establishes reliable recovery. [42][63]

Published topology comparisons show task dependence: separable financial investigations benefited in one study, while its sequential inventory-changing task favored the single-agent baseline. Matching maximum total iterations did not match realized tokens, money, or latency. Such results motivate coupling-sensitive tests; they do not supply a universal participant count. [16]

Retain coordination when it improves accepted outcomes within the task’s operating limits. Simplify when prescribed branches preserve the benefit or communication adds no useful correction. Reject a design when integration errors or repair burden outweigh its gains. Report outcome quality, elapsed time, total usage, and human work separately; one composite score can conceal the tradeoff. [47]

Open questions

1. 01

   Choosing decomposition from task coupling remains unresolved. Hidden dependencies can make apparently separate investigations require repeated coordination. Progress would mean predicting when dynamic delegation beats both a capable single agent and prescribed parallel work under comparable realized usage, including integration and repair. [5]

2. 02

   Semantic duplicate detection needs more than matching task identifiers. Different assignments can request the same investigation, while similar wording can describe deliberately independent checks. Progress would preserve useful redundancy while reducing accidental overlap on labeled task pairs and complete workflows. [38][35]

3. 03

   Shared learning needs usable authorization and attribution. Isolating every memory prevents reuse; broad sharing can expose information to the wrong participants. Progress would demonstrate cross-agent reuse with enforced reader and writer scopes, traceable contributions, and reliable correction of affected conclusions. [27]