Multi-Agent Systems

Multiple agents can explore independent paths, isolate context, and bring specialized tools or authority to one goal. They can also repeat work, amplify correlated errors, overwrite shared state, and hide cost behind recursive delegation. Agent count is not a measure of system maturity.

Thesis

Use multiple agents only when a clear boundary—parallelism, specialization, context isolation, authority separation, or independent review—earns more value than the coordination it introduces.

Each agent remains a bounded control loop. The multi-agent layer must add task ownership, communication contracts, shared-state rules, aggregate limits, termination, and failure containment. A group conversation alone provides none of these.

First ask whether another agent is necessary

Several mechanisms are often mistaken for multi-agent architecture:

• a deterministic workflow calling the same model in several steps;
• parallel retrieval or batch jobs;
• multiple samples from one model;
• a planner and verifier implemented as two prompts;
• a tool that contains internal model calls; or
• separate personas in one transcript.

These may be useful, but creating independent agent loops adds value only if they need their own goals, context, actions, feedback, state, and stopping conditions.

Justifying boundaries include:

1. Parallel exploration: independent branches can reduce elapsed time or increase coverage.
2. Specialization: a domain, language, tool set, or model configuration materially improves a bounded task.
3. Context isolation: intermediate detail would overwhelm the coordinator but can be summarized through a contract.
4. Authority separation: different identities or approvals should constrain different actions.
5. Independent review: a separately designed and evaluated process can challenge an artifact or decision.

Do not claim independence merely because two agents have different role prompts while sharing the same model, evidence, and failure assumptions.

Common topologies

Topology	Useful when	Main risk
Coordinator–workers	One owner can decompose and integrate bounded subtasks	Coordinator bottleneck and lossy summaries
Handoff chain	Responsibility moves through distinct stages or specialties	Telephone-game context loss and unclear ownership
Peer collaboration	Peers must negotiate or combine complementary views	Conversation growth and no final authority
Shared task board or blackboard	Work is dynamic and tasks can be claimed from common state	Races, duplicate claims, and stale records
Debate or review	A candidate benefits from structured challenge	Correlated errors and selection without evidence

Anthropic reports using a coordinator–worker design for a research product, with parallel subagents exploring different aspects and a lead agent synthesizing results (Anthropic, 2025). Its published lessons include large token costs and coordination and evaluation challenges. That is evidence for one research workload, not a default template for transactional or low-latency systems.

AutoGen demonstrated a framework for configurable conversations among agents using models, people, and tools across example applications (Wu et al., 2023). The research shows the flexibility of conversational coordination; application correctness still depends on explicit contracts and environmental evaluation.

Give every task and result a contract

A delegation request should include:

parent run and task ID
bounded objective and exclusions
required inputs and source versions
expected output schema or artifact
success and failure evidence
allowed tools, authority, data, and destinations
time, token, cost, and recursion limits
deadline, cancellation, and progress reporting
return, escalation, and ownership rules

The worker should return status, evidence, artifacts, assumptions, unresolved issues, actions attempted, and committed or unknown effects. “Here is what I found” is not sufficient when the parent must decide whether a subtask succeeded.

The parent remains accountable for the delegated objective unless ownership is explicitly transferred and accepted. Delegation does not transfer the requester’s authority automatically; child capabilities should be no broader than the task requires.

Coordinate through state, not only messages

Natural-language messages are useful for interpretation but weak for concurrency. Maintain shared structured records for:

• task IDs, owners, leases, dependencies, and statuses;
• input and artifact versions;
• claims and evidence identifiers;
• committed and pending effects;
• budgets and child counts;
• cancellation and deadlines; and
• join conditions and final decision owner.

Use optimistic concurrency, leases, partitioned ownership, or another suitable mechanism so workers do not silently overwrite each other. Messages should reference shared records rather than duplicate an increasingly stale world state.

Parallelism requires partition and join rules

Before spawning workers, define how work is partitioned. Good partitions differ by source set, hypothesis, domain, artifact, or independent test—not vague prompts such as “look at this another way.” Avoid giving every worker the entire problem unless genuine independent replication is the goal.

At the join:

1. validate each result against its contract;
2. reconcile duplicated or conflicting claims using evidence;
3. identify missing branches and failed workers;
4. preserve uncertainty instead of forcing consensus;
5. check aggregate budgets and effects; and
6. verify the parent goal independently.

Consensus is not truth. Several agents may reproduce the same source error or model bias. Weight claims by evidence and independence of method, not vote count.

Bound recursion and aggregate resources

A child that can create children forms a task tree or graph. Enforce limits at both run and root levels:

• maximum active workers and delegation depth;
• total and per-child tokens, calls, cost, time, and tool actions;
• global rate and external-effect limits;
• maximum retries and no-progress cycles;
• deadlines inherited from the parent; and
• cancellation propagation.

Reservation can prevent children from independently consuming the full parent budget. The trace should roll child use and effects up to the root so the apparent single request reflects its real cost and risk.

Failure containment

One worker’s malformed output, prompt injection, compromised skill, or runaway loop should not contaminate every peer. Apply:

• least-privilege identity and capability per worker;
• data minimization and tenant isolation;
• typed result validation at boundaries;
• separate untrusted content from coordination instructions;
• circuit breakers and child termination;
• immutable evidence references; and
• explicit partial-failure policy.

Decide whether the parent can succeed with a missing branch, must retry, should narrow its claim, or must escalate. Returning an incomplete synthesis as full success hides the failure.

Evaluate the architecture against a simpler baseline

Compare the multi-agent design with a single agent using the same total budget and with a deterministic parallel workflow where applicable. Measure:

• end-to-end task success and repeated-trial reliability;
• coverage and evidence quality;
• elapsed time and total computation;
• duplicate work and coordination overhead;
• handoff loss and conflict rate;
• child failure containment and cancellation latency; and
• outcome quality under partial failure.

Anthropic’s report notes that its multi-agent research system uses substantially more tokens than chat and that benefits are strongest for breadth-first tasks with parallelizable directions. Treat such vendor measurements as workload-specific motivation to run local comparisons.

Failure modes

Agent for every role label

Planner, researcher, writer, critic, and manager become separate loops without a measured boundary. Start with functions or workflow steps; add agents only when independent adaptation is needed.

Recursive delegation without root limits

Every worker can spawn a full budget. Cost and side effects grow invisibly. Aggregate resources and cap depth and concurrency.

Telephone-game handoffs

Each agent paraphrases the previous summary until evidence and constraints disappear. Pass artifact and evidence references with structured handoff fields.

Shared transcript as coordination

Workers read and write one conversation without task ownership or versions. Use a structured task board and conflict control.

Consensus illusion

Similar agents agree and the system calls the claim verified. Require evidence or independent methods and preserve dissent.

No final owner

Peers produce alternatives, but nobody is accountable for the integrated outcome. Name the decision and completion owner.

Partial failure hidden by synthesis

The coordinator writes a fluent answer after workers time out. Surface missing branches and narrow the conclusion.

Fieldbook guidance

Before adding a worker type, fill out this record:

Field	Question
Boundary	Which parallelism, specialization, context, authority, or review benefit requires a separate loop?
Baseline	Why is one agent or a deterministic workflow insufficient?
Contract	What objective, inputs, output, evidence, authority, and limits cross the boundary?
State	Where are task ownership, versions, artifacts, and effects recorded?
Coordination	How are work claims, conflicts, joins, and missing results handled?
Containment	How are data, tools, failure, injection, and cancellation isolated?
Budget	Which root and child limits prevent recursive expansion?
Evaluation	What measured gain justifies total cost and complexity?

Checklist

• Does each agent boundary have a concrete benefit that a simpler mechanism does not provide?
• Does every child have a bounded objective, result contract, authority, deadline, and budget?
• Is task and result state structured, versioned, and separate from conversation text?
• Are parallel partitions independent enough, with explicit join and conflict rules?
• Does one named owner remain accountable for the parent outcome?
• Are child permissions narrower than or equal to delegated authority?
• Are recursion, concurrency, total cost, tool actions, and external effects bounded at the root?
• Do cancellation and deadlines propagate to children?
• Are partial failures, missing branches, and dissent visible in the final result?
• Does evaluation compare against single-agent and deterministic baselines under fair budgets?

References and how they are used

• Wu et al., “AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation” — primary research example of configurable multi-agent conversation with models, people, and tools; used to illustrate flexibility rather than guarantee correctness.
• Anthropic, “How we built our multi-agent research system” — Anthropic production account supporting coordinator-worker structure, parallel research, evaluation difficulty, and substantial resource overhead; findings are scoped to that product and workload.
• Li et al., “CAMEL: Communicative Agents for Mind Exploration of Large Scale Language Model Society” — research example of role-based communicative agents; used as historical evidence of the pattern, not as a production recommendation.
• Yao et al., “τ-bench” — primary research supporting environmental outcome checks and repeatability, which remain necessary when several agents produce a plausible interaction trace.