The team that vanishes when labels are removed

The first mistake is to treat an agent as a job title. A title describes expected work. An agent boundary describes what can observe, remember, decide, authorise and survive independently.

A role is an instruction; an agent is a locus

Classical agent research distinguishes theories of agency from the architectures and languages used to implement agents. Wooldridge and Jennings describe agent architectures as engineering models intended to realise specified agent properties, rather than as labels attached to arbitrary software components.[2] The distinction matters more, not less, when language models make role-play cheap.

For architecture decisions, a useful operational definition is narrower than philosophy and stricter than marketing. An agent is a persistent locus of observation, local state, policy and bounded action. It need not be conscious, human-like or embodied. It does need a trajectory that can differ from another locus because its information, authority or environment differs.

Under this definition, several common designs are not yet multi-agent systems:

Count loci, not calls

A useful count begins with a counterfactual, not a runtime trace. Hold the task, model family, tool access, output contract and total inference budget fixed. Then merge two candidate agents. If repeated trials preserve outcome quality, latency, accessible evidence, permission and recovery behaviour, the merge removed an implementation boundary rather than a causal one.

The test has three possible results. In the first, the merged workflow is equivalent. The extra agent was a role wrapper and should usually become a typed function. In the second, the merged workflow is worse only because one context is too small, one model cannot select reliably among many skills, or one process cannot exploit available compute. That is a measured capacity constraint. It may justify sharding today, but the decision should be revisited when models, context windows or runtimes change.

In the third result, merging destroys a property the task requires. One observation is no longer local at the moment of action. One principal can now both propose and approve. Independent work is forced onto a sequential critical path. Two supposedly separate judgements become one error source. Only this third result establishes causal multiplicity; the second establishes an engineering contingency.

This distinction prevents two opposite mistakes. It stops teams from calling every staged prompt a society. It also avoids demanding metaphysical independence from useful distributed software. The architecture question is modest: does the boundary preserve a task-relevant difference under the failure assumptions that matter?

The causal ladder

The same language model can appear at every level of Figure 2. Model identity therefore does not settle the architecture. What matters is how far the candidate boundary reaches. Separate prompts create different instructions. Separate contexts create different accessible histories. Persistent local state creates different trajectories. Separate authority creates different permitted actions. Separate environments create observations that cannot be obtained merely by rereading a shared transcript.

Frameworks such as AutoGen make conversational agent patterns easy to express and customise.[6] That is evidence of implementation flexibility, not evidence that a task needs several agents. The necessity claim requires a counterfactual comparison with a simpler architecture.

A helpful default follows. Begin with one reasoning locus, explicit tools and typed state. Fork contexts when you need candidate diversity. Add a persistent agent only when the boundary itself carries a requirement. Multiplicity should be an answer to a task constraint, not the starting aesthetic.

flowchart LR
  A["Six nameplates in a control room"] --> B["The team that vanishes when<br/>labels are removed"]
  B --> C["Separation that cannot be<br/>compiled away"]
  C --> D["The coordination break-even<br/>surface"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#007D68,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

Separation that cannot be compiled away

Three separations repeatedly survive the replacement test: local state, authority and time. A fourth, epistemic independence, can create value, but only when it changes the error-generating process rather than the cast list.

Local state: the world arrives at different places

Imagine two crane controllers on opposite sides of a harbour. Each sees local load, wind and proximity measurements every ten milliseconds. Their joint objective is to move containers without collision. A central planner could, in principle, ingest all sensors and issue every command. The question is not whether centralisation is mathematically imaginable. The question is what assumptions it adds.

Centralisation requires the network to be timely, available and trusted. It moves the safety boundary from each crane to the link and the planner. It may also transmit observations that policy requires to remain local. If the cranes must continue safely during partition, each needs local state and a local policy. The agents are justified because the observations and deadlines are spatially attached to different action loci.

Formal work on decentralised partially observable control shows why this is not free. In a Dec-POMDP, agents act from local observation histories while joint actions determine shared outcomes. Bernstein and colleagues showed that even finite-horizon problems with two decentralised agents are extremely hard in the worst case.[3] The lesson is not that decentralisation should be avoided. It is that local information can make several agents necessary while simultaneously making optimal coordination expensive.

Authority: two labels do not create two principals

Consider a payment exception. One component proposes release. Another component approves it. If both use the same service identity and either can call the release API, the separation exists only in prose. A prompt saying “act as an independent approver” does not revoke credentials.

Security practice treats separation of duties as a control against misuse of authorised privileges. NIST describes the principle as preventing any one user from holding enough privilege to misuse a system alone, with the two-person rule as a familiar dynamic form.[4] For agent systems, this creates a sharper requirement: different agents count as different authorities only when identities, capability grants and enforcement paths differ.

Time: parallel work can shorten the critical path

A task may be centrally solvable yet still benefit from several agents because independent work must finish before a deadline. The relevant variable is not task size. It is the fraction that can proceed without waiting for shared intermediate state.

Every symbol describes a concrete delay. The first term is work that cannot overlap. The second is divisible work. The final term includes dispatch, context packaging, duplicate effort, reconciliation and waiting. The equation assumes equal task sizes and adequate resources. Remove either assumption and the gain shrinks.

Parallelism is a property of the dependency graph, not of the number of boxes available. A single runtime can execute independent tool calls concurrently. Several persistent agents are justified only when local state, scheduling autonomy or failure isolation also matters, or when the chosen runtime cannot otherwise exploit the available parallelism.

Evidence: disagreement is useful only when errors can differ

Multi-agent debate can improve factuality and reasoning in some settings, as early work demonstrated.[5] Yet extra voices do not automatically create independent evidence. Homogeneous teams can converge through social influence, shared retrieval and a common model prior. Recent work reports both consensus collapse and conditions under which better incentives or protocols restore gains.[10][11]

The practical distinction is between output diversity and error-source independence. Independence may come from different evidence stores, sensors, model families, retrieval strategies, training provenance or withheld contexts. It must be designed and measured. Agent count is only a proxy, and often a poor one.

The coordination break-even surface

Once a task has a plausible separation benefit, the next question is economic and causal: is that benefit larger than the dependencies the team must now manage?

Coordination is the price of dependency

Malone and Crowston define coordination as managing dependencies among activities.[1] That definition prevents a common error. Communication is not automatically coordination. A message has value only when it resolves a dependency: who uses a resource, which result another task awaits, whose state is authoritative, or how conflicting actions are reconciled.

Every agent boundary introduces at least one dependency that did not exist inside a single local loop. A fact must be packaged into a message. The receiver must interpret it. State may change while the message travels. Two agents may act from incompatible snapshots. Someone must decide when enough work has been done and whether the joint result is complete.

The paper’s central instrument is therefore a break-even equation:

The benefit terms are local-state value L, authority-separation value A, parallel-work value P and independent-evidence value D. The costs are messaging and context duplication M, reconciliation and stale-state risk R, verification and termination V, security and privilege surface S, and observability, evaluation and recovery burden O.

These terms are not universal units. For a real decision, translate each into the objective that matters: success probability, elapsed time, monetary cost, expected harm, reviewer load or a policy invariant. Use a common utility scale only after the organisation has stated how it values quality, delay and failure.

Why the equation is a gate, not a licence to average away safety

The additive form is deliberately simple. It assumes that benefits and costs can be compared on a declared decision scale and that one term does not silently change another. That assumption is often false. A stale hand-off can erase an accuracy gain. A shared credential can nullify the claimed authority separation. A supervisor bottleneck can remove the latency benefit of parallel workers. These interactions create cliffs on the break-even surface, rather than only gentle deductions.

Consequential systems should therefore separate optimisation from constraints. Use expected utility to compare ordinary outcomes, but treat certain conditions as gates: no increase in severe violations, no action from expired evidence, no unresolved duplicate effect and no privilege path that bypasses the intended separation. A design with higher average utility still fails when it crosses one of those boundaries. Safety invariants are not negative points that more task accuracy can purchase back.

The same discipline applies to independence. Two agents do not provide twice the evidence when they use the same model, prompt template, retrieval index and supervisor. Their errors may be strongly correlated. The value term D should be estimated from incremental error reduction after controlling for shared causes, not from the number of votes. Vary model family, evidence source or method only when the added diversity is relevant to the anticipated failure.

Finally, estimate the margin as a distribution. Pair the same tasks across architectures, repeat stochastic runs and report the lower confidence bound, not only the mean. A five-unit average advantage that ranges from a ten-unit gain to an eight-unit loss has not earned a persistent organisation. The break-even rule asks for positive value with enough margin to survive ordinary drift, not a favourable point estimate.

What the evidence currently permits

Recent empirical evidenceA controlled study across 260 configurations, six agent benchmarks, five architectures and three model families found large variation by task structure. Relative performance ranged from a substantial gain on decomposable financial reasoning to a severe loss on sequential planning. Agent count itself was not a significant main effect in the reported model, while interactions with task structure and coordination mattered.[8]

That result aligns with the break-even thesis but does not prove a universal law. The authors report restricted transfer and several limitations, including moderate team sizes and cross-domain prediction difficulty. It is best read as strong evidence that architecture-task alignment matters, not as a portable coefficient table for every deployment.

Failure taxonomyCemri and colleagues analysed more than 1,600 traces across seven frameworks and organised failures into system-design issues, inter-agent misalignment and task-verification problems.[7] These are precisely the costs that disappear from a demo diagram when arrows are treated as free.

Preliminary reportThere is also direct evidence that some multi-agent role structures are compressible. A technical report compiled selected pipelines, iterative workflows and router-worker designs into one agent with internal skills. In its tested homogeneous setting, the compiled agent used fewer calls, tokens and less latency while preserving comparable accuracy. The authors explicitly limit the claim to compilable systems and report a capacity boundary when skill libraries become difficult to select from.[9]

A single agent may have finite context, skill-selection and control capacity. Dividing work can therefore help even when no separation is logically necessary. That is a legitimate engineering reason, but it remains contingent on model, task and implementation. Treat it as a measured capacity limit, not as evidence that “societies” are intrinsically smarter.

stateDiagram-v2
  [*] --> Claim
  state "A role is an instruction; an<br/>agent is a locus" as Claim
  state "Count loci, not calls" as Test
  state "The causal ladder" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Build the smallest organisation the task demands

The correct test is not a static checklist. It is a staged comparison that first tries to remove agents, then measures what survives.

A realistic configured system

Consider Tidegate, a synthetic system for reviewing supplier-payment exceptions. Each case contains a purchase order, invoice, receipt, supplier-master record, sanctions result and current account status. Some evidence changes while the review is running. A release can be expensive and difficult to reverse.

A fashionable design might create a planner, document analyst, risk critic, compliance agent, payment agent and supervisor. Tidegate instead begins with the properties that must remain separate:

• The evidence compiler may read commercial documents but cannot execute a payment.
• The registry verifier uses a separately governed supplier and sanctions path. It receives claims to test, not the compiler’s full rationale.
• The operational world state comes from authoritative systems at a declared cutoff. It is not reconstructed from conversational “memory”.
• A deterministic authority kernel checks identity, purpose, permission, freshness, amount thresholds and duplicate-prevention keys.
• The executor accepts only a typed, authorised action and returns an effect receipt followed by readback.

This configuration may justify two reasoning agents because it preserves evidence-path independence and allows concurrent review. Yet the agents do not own release authority. The system places probabilistic proposal inside deterministic control. If the independent registry adds no information, or if both agents can be compiled into one isolated tool-using process without weakening policy, the second agent should be removed.

The four-stage adoption test

Stage one: compile. Replace role-to-role messages with one agent invoking typed skills. Preserve total token and tool budgets. If quality, latency and controls remain acceptable, stop. The multi-agent claim has failed its first counterfactual.

Stage two: isolate the claimed value. If the benefit is parallelism, keep evidence and authority identical while varying concurrency. If it is independence, compare shared-source and independent-source conditions. If it is authority, inspect capability paths rather than prose. Change one causal property at a time.

Stage three: match resources. Compare against the strongest one-agent baseline allowed the same total model tokens, tools, retries and wall-clock opportunities. Otherwise “collaboration gain” may be merely more inference. Include forked single-agent sampling because it often captures diversity without persistent coordination.

Stage four: inject coordination failure. Drop a message. Delay one agent. Change world state between proposal and action. Give two agents contradictory evidence. Corrupt the supervisor’s summary. Revoke permission after planning but before execution. A design is not justified if its headline gain disappears under failures created by its own topology.

Build the comparison before the organisation

A fair baseline is a ladder, not a straw man. Begin with deterministic software for tasks whose rules are already known. Add one tool-using agent when interpretation is required. Add isolated skill stages when context management is the bottleneck. Add parallel samples when candidate diversity may help. Only then add persistent agents with messages and local state. Each rung should inherit the strongest controls of the rung below it.

Resource matching needs equal care. Equalising agent count is meaningless. Match or account for total model tokens, tool calls, wall-clock allowance, retries, retrieved evidence and human intervention. When a four-agent team receives four times the inference budget, compare it with a single agent allowed four independent attempts and a deterministic selector. Otherwise the experiment confounds organisation with purchased computation.

Measure the burden created by topology as well as headline accuracy. Record message volume, duplicated context, disagreement rate, stale-state incidents, supervisor compression loss, abandoned branches, permission checks, recovery time and the fraction of failures that would not exist in the simpler design. These are not operational footnotes. They are empirical values of the cost terms in the break-even equation.

Predeclare the removal rule. For example: retire the second agent if its lower-bound utility advantage is non-positive for two evaluation windows, if severe coordination failures rise above the single-agent baseline, or if its claimed evidence source becomes shared. An agent boundary should be reversible by design because its justification is empirical, not ceremonial. This converts architecture review from a one-time approval into a monitored causal claim.

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import csv
import random
from dataclasses import dataclass
from pathlib import Path
from statistics import mean
from typing import Iterable


@dataclass(frozen=True)
class Weights:
    success_value: float = 100.0
    latency_cost_per_second: float = 0.02
    token_cost_per_1k: float = 0.50
    severe_failure_penalty: float = 250.0
    coordination_failure_penalty: float = 70.0


@dataclass(frozen=True)
class Trial:
    task_id: str
    architecture: str
    success: int
    latency_s: float
    tokens: int
    severe_failure: int
    coordination_failure: int


def utility(trial: Trial, weights: Weights) -> float:
    return (
        weights.success_value * trial.success
        - weights.latency_cost_per_second * trial.latency_s
        - weights.token_cost_per_1k * trial.tokens / 1000
        - weights.severe_failure_penalty * trial.severe_failure
        - weights.coordination_failure_penalty * trial.coordination_failure
    )


def read_trials(path: Path) -> list[Trial]:
    required = {
        "task_id", "architecture", "success", "latency_s", "tokens",
        "severe_failure", "coordination_failure",
    }
    with path.open(newline="", encoding="utf-8") as handle:
        reader = csv.DictReader(handle)
        missing = required.difference(reader.fieldnames or [])
        if missing:
            raise ValueError(f"Missing columns: {sorted(missing)}")
        return [
            Trial(
                task_id=row["task_id"],
                architecture=row["architecture"],
                success=int(row["success"]),
                latency_s=float(row["latency_s"]),
                tokens=int(row["tokens"]),
                severe_failure=int(row["severe_failure"]),
                coordination_failure=int(row["coordination_failure"]),
            )
            for row in reader
        ]


def synthetic_trials(n: int = 300, seed: int = 62) -> list[Trial]:
    """Create paired synthetic data. A favourable mean still has wide uncertainty."""
    rng = random.Random(seed)
    rows: list[Trial] = []
    for i in range(n):
        difficulty = rng.betavariate(2.4, 2.0)
        shared_shock = rng.random() < 0.06
        p_single = max(0.25, 0.92 - 0.48 * difficulty - 0.18 * shared_shock)
        p_multi = max(0.28, p_single + 0.055 - 0.10 * (difficulty > 0.78))
        single_success = int(rng.random() < p_single)
        multi_success = int(rng.random() < p_multi)
        single_severe = int(rng.random() < 0.025 + 0.02 * difficulty)
        multi_severe = int(rng.random() < 0.020 + 0.02 * difficulty)
        multi_coordination = int(rng.random() < 0.05 + 0.08 * difficulty)
        rows.extend([
            Trial(f"case-{i:04d}", "single", single_success,
                  42 + 35 * difficulty, int(5200 + 2500 * difficulty),
                  single_severe, 0),
            Trial(f"case-{i:04d}", "multi", multi_success,
                  36 + 30 * difficulty, int(8300 + 3600 * difficulty),
                  multi_severe, multi_coordination),
        ])
    return rows


def paired_deltas(trials: Iterable[Trial], weights: Weights) -> tuple[list[float], float]:
    by_task: dict[str, dict[str, Trial]] = {}
    for trial in trials:
        by_task.setdefault(trial.task_id, {})[trial.architecture] = trial
    deltas: list[float] = []
    severe_delta = 0.0
    paired = 0
    for task_id, pair in by_task.items():
        if "single" not in pair or "multi" not in pair:
            continue
        paired += 1
        deltas.append(utility(pair["multi"], weights) - utility(pair["single"], weights))
        severe_delta += pair["multi"].severe_failure - pair["single"].severe_failure
    if not deltas:
        raise ValueError("No paired single and multi trials found")
    return deltas, severe_delta / paired


def bootstrap_ci(values: list[float], draws: int, seed: int = 62) -> tuple[float, float]:
    rng = random.Random(seed)
    n = len(values)
    samples = sorted(mean(rng.choices(values, k=n)) for _ in range(draws))
    return samples[int(0.025 * draws)], samples[int(0.975 * draws)]


def main() -> None:
    parser = argparse.ArgumentParser(description="Resource-matched multi-agent break-even gate")
    parser.add_argument("--csv", type=Path, help="Optional measured paired trial CSV")
    parser.add_argument("--margin", type=float, default=3.0)
    parser.add_argument("--draws", type=int, default=5000)
    args = parser.parse_args()

    trials = read_trials(args.csv) if args.csv else synthetic_trials()
    source = str(args.csv) if args.csv else "synthetic demonstration"
    weights = Weights()
    deltas, severe_delta = paired_deltas(trials, weights)
    delta_mean = mean(deltas)
    low, high = bootstrap_ci(deltas, args.draws)

    passes = delta_mean >= args.margin and low > 0 and severe_delta <= 0
    verdict = "PASS bounded pilot gate" if passes else "FAIL return to simpler architecture"

    print(f"Data: {source}")
    print(f"Paired tasks: {len(deltas)}")
    print(f"Mean multi-minus-single utility: {delta_mean:.2f}")
    print(f"95% paired-bootstrap interval: [{low:.2f}, {high:.2f}]")
    print(f"Severe-failure-rate delta: {severe_delta:+.3%}")
    print(f"Verdict: {verdict}")


if __name__ == "__main__":
    main()

The failure case that should stop the build

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: Six nameplates in a control room
  M->>E: A role is an instruction; an agent is a locus
  E-->>M: compare rival explanations
  E->>D: Add another agent only when separation earns it
  D-->>Q: revise scope or act

Add another agent only when separation earns it

The usual architecture conversation begins too late. A team discusses supervisor patterns, debates, swarms and hand-off protocols before establishing that several agents are needed. The result is an organisation designed in search of a dependency.

The decision should now begin with a deletion test. Draw the proposed agents. Merge them one by one. For each merge, ask whether any observation becomes unavailable, any deadline becomes impossible, any policy separation disappears, or any independent evidence path collapses. If nothing material changes, continue merging.

What remains is the smallest causally meaningful organisation. It may be one agent with tools. It may be one agent plus parallel samples. It may be one proposal agent, an independent verifier and a deterministic authority kernel. It may be a genuinely distributed set of controllers because the world itself is distributed.

The new default is one agent until separation earns another. This is not a preference for monoliths. It is a preference for paying coordination costs only when a named task property purchases something centralisation cannot provide under the required trust, latency and failure assumptions.

Simplicity here does not mean forcing every observation and decision into one process. It means centralising only what can be centralised without changing the task’s causal structure. A local controller may remain separate while sharing a deterministic coordination protocol. An independent verifier may remain separate while receiving only the claim it must test. A proposal agent may be stateful while the authority kernel remains stateless and replayable. The smallest organisation is therefore not always the fewest software components. It is the fewest independent reasoning and action loci consistent with the required guarantees.

The decision must also be revisited. A new shared retrieval layer can destroy evidence independence. A faster network can make local planning unnecessary. A larger context window can absorb a former skill-selection bottleneck. A regulatory change can create a new separation-of-duties requirement. Record the property that justified each boundary, the metric that tests it and the event that triggers reassessment. An architecture that once cleared the break-even surface should be merged, split or constrained when those conditions change.

The practical choice is therefore precise:

1. Use one agent with typed tools when roles share state, authority and time.
2. Use forked deliberation when you need candidate diversity but not persistent interaction.
3. Use several agents when local state, enforced authority, true concurrency or independent evidence survives the replacement test.
4. Keep permission, invariants and effect verification outside probabilistic conversation.
5. Retain the team only while measured break-even evidence remains positive under change and failure.

That decision is less glamorous than “build a society of agents”. It is also more consequential. It turns agent count from an architectural fashion into a claim that can be weakened, tested and reversed.

Glossary

Agent locus

A persistent boundary around observation, state, policy and bounded action.

Compilation test

A counterfactual merge that preserves resources and asks what task-relevant property disappears.

Coordination tax

Messaging, reconciliation, verification, security and recovery costs introduced by plurality.

Non-compressible separation

A difference in state, authority, time or evidence that cannot be removed without changing required behaviour or guarantees.

Authority kernel

A deterministic enforcement boundary that evaluates identity, purpose, permission, freshness and action invariants.

Resource matching

Comparing architectures under equivalent tokens, tools, retries, time and human intervention.

References

1. Malone, T. W. and Crowston, K. (1994). “The interdisciplinary study of coordination.” ACM Computing Surveys, 26(1), 87–119. Publisher record and DOI.
2. Wooldridge, M. and Jennings, N. R. (1995). “Intelligent agents: theory and practice.” The Knowledge Engineering Review, 10(2), 115–152. Publisher record and DOI.
3. Bernstein, D. S., Givan, R., Immerman, N. and Zilberstein, S. (2002). “The complexity of decentralized control of Markov decision processes.” Mathematics of Operations Research, 27(4), 819–840. Publisher record and DOI.
4. National Institute of Standards and Technology. SP 800-53 Rev. 5: Security and Privacy Controls for Information Systems and Organizations, including AC-5 separation of duties and AC-6 least privilege. Official NIST record.
5. Du, Y., Li, S., Torralba, A., Tenenbaum, J. B. and Mordatch, I. (2023; ICML 2024). “Improving factuality and reasoning in language models through multiagent debate.” arXiv record.
6. Wu, Q. et al. (2023; COLM 2024). “AutoGen: Enabling next-gen LLM applications via multi-agent conversation.” arXiv record.
7. Cemri, M. et al. (2025). “Why do multi-agent LLM systems fail?” arXiv record, dataset and taxonomy links.
8. Kim, Y. et al. (2025, revised 2026). “Towards a science of scaling agent systems.” arXiv record.
9. Li, X. (2026). “When single-agent with skills replace multi-agent systems and when they fail.” Technical report. arXiv record.
10. Bertalanič, B. and Fortuna, C. (2026). “The cost of consensus: isolated self-correction prevails over unguided homogeneous multi-agent debate.” arXiv record.
11. Chen, Y., Niu, G., Cheng, J., Han, B. and Sugiyama, M. (2026). “When and why does multi-agent debate fail and does it really underperform?” arXiv record.