Choosing Topology from Task Structure

Six specialists, one reusable mistake

A team is asked to produce a decision brief from six sources. There is a financial table, a policy document, a legal clause, a customer letter, a market note and a prior decision. The architecture diagram is drawn before anybody studies the work: six specialist agents, one for each source, all connected to one another. The diagram looks collaborative. It also commits the system to thirty directed communication possibilities before the first useful dependency has been named.

Now change only the task. In the first version, each specialist extracts a typed result and one synthesiser combines the six outputs. Direct specialist-to-specialist communication adds little. A star is enough. In the second version, the legal interpretation changes which financial calculation is relevant, and the calculation may expose a policy exception that sends the legal agent back to a different clause. The work contains reciprocal dependence. A one-shot star hides the revisions, while a bounded feedback loop or small dynamic graph may be justified. In the third version, all six agents answer the same question from the same evidence and then vote. The extra nodes create redundancy but no new information.

The number and identity of agents do not determine the topology. The dependency structure of the task does. This distinction sounds modest, yet it reverses the usual design sequence. Instead of choosing “supervisor”, “swarm”, “debate” or “hierarchy” and forcing the work into that shape, first model what must precede, inform, contest, allocate, revise or authorise what. The topology follows as a coordination mechanism.

Coordination theory gives the durable starting point: coordination manages dependencies among activities.¹ Earlier multi-agent research catalogued hierarchies, teams, markets and other organisational forms, while warning that structure has measurable performance consequences.² Modern language-agent systems rediscover the same problem through graphs, conversation patterns and dynamic routing. The models are new; the burden of matching structure to dependence is not.

Central answer. Compile the agent communication graph from five task relations: precedence, aggregation, allocation, contest and revision. Then overlay authority as a separate graph. Every edge should have a named dependency it manages, a message contract, a cost and a failure test.

Part I

The graph exists before the agents

A task is not a bag of subtasks. It is a set of transformations joined by constraints. One activity may need another's output. Several activities may compete for the same resource. Independent findings may need aggregation. Two hypotheses may need deliberate contest. A discovery may invalidate the plan that produced it. These relations exist whether the workers are people, programs, models or mixed teams.

Represent the work as a directed, typed graph G_T = (V, D). Each node in V is a task that produces an inspectable artefact. Each edge in D names a dependency, not merely the fact that two nodes exchange text. For this paper, five relations form a practical working vocabulary:

Precedence

Task B cannot begin, or cannot finish correctly, until A produces a valid result. This is the natural source of a chain.

Aggregation

Several conditionally independent outputs contribute to one synthesis. This often produces a star or a level within a hierarchy.

Allocation

A task must be assigned among substitutable providers under cost, time, capability or load constraints. This can justify a market.

Contest

Several workers address the same proposition because disagreement itself carries information. This is the narrow case for debate.

Revision

An intermediate result changes another task's assumptions, scope or method. This creates reciprocal coupling and may require bounded loops.

Authority

A result may propose an effect, but the right to execute that effect belongs to a separate principal or deterministic control surface.

The sixth item is displayed beside the five task relations because teams often draw it as though it were another communication edge. It is not. An analyst sending a finding to an executor does not, by that message alone, acquire the executor's permission. The existing article Designing Multi-Agent Topologies with Computable Blast Radius develops that authority problem in depth. The present paper asks the earlier question: which communication edges were justified by the task before authority was granted at all?

Classical blackboard systems show one early answer to aggregation: specialised knowledge sources operate around a shared problem state rather than forming a fully connected conversation.³ Contract Net shows an answer to allocation: a manager announces work and potential contractors propose terms.⁴ These are not historical curiosities. They reveal that a topology is a method for resolving a particular dependency.

Language-agent frameworks make it easy to wire conversations in almost any pattern. AutoGen, for example, was introduced as infrastructure for programmable multi-agent conversation patterns.⁵ Graph frameworks such as GPTSwarm represent operations and communication channels explicitly, then optimise nodes or edges.⁶ Flexibility is useful, but it does not answer the design question. A framework can express an edge without proving that the task needs it.

Figure 2. Four overlays prevent a category error. Conceptual figure. Dependency and information justify communication. Uncertainty may justify adaptation. Authority constrains effects but must not be inferred from connectivity.

Three graphs, not one

A defensible design keeps at least three structures:

The task graph records activities and typed dependencies.
The communication graph records which configured workers may send which artefacts to whom.
The authority graph records which identities may invoke which consequential capabilities under what limits.

The communication graph should be a projection of the task graph, not a copy. A task may have ten data dependencies but only three need an agent message because a deterministic join or shared evidence store can manage the others. Conversely, one task dependency may need several communication edges when independent verification is required. The authority graph is usually smaller still. Many agents can propose; few should execute.

Practitioner synthesis. This projection can be made explicit as a decision heuristic. Let τ denote a candidate topology. Choose the topology that minimises a local design loss:

τ* = arg min over τ [ L_task(τ) + λm M(τ) + λt T(τ) + λa A(τ) + λr R(τ) ]

L_task is expected loss from dependencies the topology fails to manage. M is message and token cost. T is coordination latency. A is authority exposure created by the configured identities and tools. R is recovery and observability debt, including the difficulty of reconstructing why the route changed. The λ terms are local decision weights, not universal constants. Raising the weight on latency favours parallel or simpler structures. Raising the weight on authority exposure favours narrow execution paths. Raising the weight on unresolved dependence may justify more communication.

Two constraints sit outside the weighted sum. Every dependency that can change correctness must have a named mechanism. Every consequential effect must pass an independently enforceable authority boundary. A cheap topology that silently drops an essential dependency is not efficient. A high-scoring topology that lets a message carry ambient permission is not governed.

Published evidence, bounded interpretation. Formal work on decentralised partially observable control shows that optimal planning can become extremely hard even with few agents.⁷ That result concerns specific mathematical models, not language agents directly. Its design lesson is narrower: decentralisation does not make coordination complexity disappear.

Part II

The argument in one passChart · flow

flowchart LR
  A["Six specialists, one reusable<br/>mistake"] --> B["The graph exists before the agents"]
  B --> C["Six shapes and the dependency<br/>signatures that earn them"]
  C --> D["A topology selection procedure<br/>that can reject multi-agent<br/>design"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#087A98,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

A structural route through Choosing Topology from Task Structure, from Six specialists, one reusable mistake to Stop drawing the team before drawing the…. Reading use: follow the relation, then test it against the surrounding evidence and limits.

Six shapes and the dependency signatures that earn them

The shapes below are families, not vendor features. Real systems are often hybrids: a hierarchy can contain parallel stars, a market can allocate tasks into chains, and a dynamic graph can be bounded inside one branch. The selection rule is still useful because each local region should be able to state which dependency justified its shape.

Recent primary evidence. A controlled 2026 preprint compared 260 configurations across six benchmarks, five canonical architectures and three model families while standardising tools, prompts and compute. Relative performance ranged from a reported 80.8 per cent gain on decomposable financial reasoning to a 70.0 per cent loss on sequential planning, and the authors identified the best architecture for 87 per cent of held-out configurations.¹⁶ These are benchmark-specific preprint results, not a universal law. Their value here is the controlled contrast: changing the coordination structure can help or harm even when much of the surrounding system is held steady.

Dependency signature	Candidate topology	What it buys	Failure boundary	Matched baseline
Fixed one-way transformations with narrow artefacts	Chain	Simple order, local validation, easy replay	Feedback, branching or an early error that contaminates every later stage	One agent with deterministic functions
Independent branches with one integration point	Star	Parallelism and central synthesis	Hub overload, context compression and hidden cross-spoke dependence	Single agent using parallel tools
Recursive, modular decomposition with bounded local ownership	Hierarchy	Scale, local context and narrow escalation	Cross-subtree coupling and lossy summaries	Flat star with the same workers
Substitutable providers and observable award criteria	Market	Adaptive allocation under changing cost or capacity	Latent quality, strategic bids or tightly coupled tasks	Rule-based scheduler
One contested proposition with independent evidence	Debate	Error exposure through structured disagreement	Correlated evidence, social convergence or weak adjudication	Self-consistency or ensemble vote
Useful next steps change after intermediate observations	Dynamic graph	Adaptive routing and variable team size	Unbounded messages, unstable routing and poor replay	Best static graph under the same budget

Chain: when the artefact moves one way

A chain is appropriate when the task resembles a typed transformation pipeline. One stage produces an artefact that the next can validate and consume: extract fields, normalise values, calculate a ratio, apply a rule, draft a summary. The topology earns its simplicity from precedence. Each handoff can state a schema, precondition, postcondition and rejection path.

The chain fails when later stages need to reinterpret earlier evidence rather than reject a malformed artefact. If a policy exception changes the meaning of a financial input, the relation is no longer one-way. Adding a hidden “ask previous agent” tool does not preserve a chain; it creates a feedback graph that should be modelled and tested as such. MetaGPT's assembly-line framing is a useful example of deliberate sequential role structure, and its own motivation includes reducing cascading inconsistency through standard operating procedures.⁸ That is a task-specific design, not evidence that pipelines are universally superior.

Star: when branches are independent until synthesis

A star places a lead or synthesiser at the centre and sends bounded work to spokes. It is strong when branches can progress independently and return compact evidence. Breadth-first research is a natural case: one subagent studies regulation, another implementation, another negative results, and a lead integrates. Anthropic's published engineering account describes such a lead-agent and parallel-subagent structure for open-ended research, while also reporting coordination errors, excessive spawning and the need for durable state and human evaluation.⁹ Treat that account as an implementation report, not a general benchmark theorem.

The hub becomes the compression boundary. If every spoke returns an essay, the centre receives more text but not necessarily more decision-relevant information. Require evidence packets: claim, source, confidence, unresolved contradiction and recommended next dependency. If two spokes must repeatedly negotiate with each other, either move that work into one bounded subteam or acknowledge that the local topology is no longer a star.

Hierarchy: when decomposition repeats

A hierarchy is a recursive pattern. A parent decomposes work into subproblems, each child may decompose further, and summaries roll upward. It is justified by modularity: the child subtree can make progress with bounded context and a stable interface to its parent. Hierarchies also support narrow authority, because analysis can be distributed while approval and execution converge towards a small root.

Its characteristic failure is information loss at boundaries. A parent may receive a clean summary after a child silently discarded the detail that should have changed another branch. Cross-subtree dependencies are therefore design signals. When they are frequent, add an explicit lateral edge, move the coupled tasks under one parent, or abandon the hierarchy for that region. Do not let children discover each other through shared memory and then continue claiming a tree.

Market: when allocation is the real problem

A market topology does not mean agents haggle theatrically in natural language. It means task allocation is resolved through proposals against an observable objective. The Contract Net Protocol formalised a manager announcing work, participants proposing, and the manager awarding based on criteria.⁴ The later FIPA specification makes the sequence explicit and allows criteria such as price, completion time or fair distribution.¹⁰

Markets are useful when providers are meaningfully substitutable, capacity changes, and the award metric predicts execution quality. They are weak when quality is latent until long after completion, when tasks interact strongly, or when bidders can optimise the metric without delivering the intended outcome. A model's confident promise is not a bid. A bid needs a capability claim tied to evidence, a cost, a deadline, a failure condition and an effect-free award. The winner receives a task, not ambient permission to act on every resource the manager can reach.

Figure 3. A market topology manages allocation. Synthetic sequence, not measured data. The award function evaluates typed bids. Execution occurs under the selected provider's own scoped authority, not through transferred ambient power.

Debate: when disagreement carries independent information

Debate is the most over-applied topology because its visible behaviour resembles intelligence. Several agents produce answers, criticise one another and converge. Early work reported gains on selected reasoning and factuality tasks.¹¹ Later evaluations found that debate did not reliably beat self-consistency or other prompting baselines without tuning, and a broader 2025 study found that representative debate methods failed to consistently outperform simple single-agent baselines under matched comparison.¹²¹³

The mechanism is not “more voices”. It is independent error exposure. Debate has a chance when participants can retrieve different evidence, use different tools, apply genuinely different methods, or hold deliberately opposed hypotheses. It is weak when identical models read the same context and merely react to one another's prose. Social influence can reduce diversity before the judge sees it.

The judge is part of the topology. If it shares the same blind spot, preference or context contamination, the debate can become a confidence amplifier. Preserve the original evidence packets, adjudicate claims rather than personalities, and compare against a cheaper ensemble that generates independent answers without conversation. If the ensemble matches or beats debate, the interaction edges did not earn their cost.

Figure 4. More debaters can add less information. Illustrative relationship. As error correlation rises, additional participants are less likely to expose a new failure while communication and adjudication costs continue to accumulate.

Dynamic graph: when the useful path is not knowable in advance

A dynamic graph changes active agents or edges during execution. It is justified when intermediate findings alter the task itself: a security review discovers a dependency that requires a cryptography specialist; a research lead reveals that one jurisdiction, not five, matters; a code repair uncovers a generated client that shifts work from application logic to schema migration.

DyLAN models agents at time steps as nodes and communication channels as edges, then performs task-oriented team selection and dynamic reformation.¹⁴ GPTSwarm similarly treats agents as composite computational graphs and explores edge optimisation.⁶ These papers establish that graph structure can be represented and optimised. They do not establish that an unconstrained dynamic graph is the correct production default.

A July 2026 preprint, MANTA, pushes the same idea into inference time: it initialises a task-conditioned topology, monitors collaboration traces and applies bounded updates to roles, links, order, visibility and validation paths while preserving the task interface and agent budget.¹⁷ Its reported benchmark gains are early evidence, not settled operating guidance. The useful design claim is narrower: runtime adaptation should be a controlled state transition with explicit invariants, rather than an unlogged invitation for agents to reorganise themselves.

Runtime rewiring creates a second-order control problem: the system must decide not only what to do, but who should communicate next. Every change needs a trigger, an allowed edge set, a budget, a state update and a replay record. Dynamic topology should be bounded by a static envelope. The runtime may activate one of the pre-authorised evidence routes, but it should not invent new authority paths.

Part III

A topology selection procedure that can reject multi-agent design

The selector begins with a baseline, not a topology. Ask whether one configured agent, one deterministic workflow, or one model using parallel tools can manage the dependencies. Additional agents need a causal reason: separate context, distinct evidence, specialist tools, independent verification, ownership or containment. Prompt variety alone is not enough.

Define the decision and final artefact. A vague goal produces a vague graph. State what must be decided, produced or verified.
Decompose into inspectable tasks. Each node should have an input contract, output contract and completion test.
Label every dependency. Use precedence, aggregation, allocation, contest or revision. Delete edges labelled only “collaborates with”.
Measure coupling and uncertainty. Ask whether branches are independent, whether they need mutual revision, and whether the next useful task is knowable before execution.
Separate evidence from authority. Decide which nodes may propose, verify, approve and execute. Draw those edges on a different layer.
Generate the smallest candidate topology. Map the dominant dependency signature to chain, star, hierarchy, market, debate or dynamic graph. Hybrids are built locally.
Run matched baselines and failure injection. Hold model, tools, token budget and evaluation constant where possible. Break the hub, corrupt a handoff, correlate the debaters, lie in a bid and remove a dynamic route.

Compile the graph in two passes

The first pass is semantic. Create a dependency record for every ordered pair of tasks that can affect the final decision. The record names the relation, the artefact required, its criticality and the condition under which it becomes relevant. A useful compact form is dependency(source, target, type, trigger, contract, criticality). “Legal review informs finance” is too weak. “A confirmed covenant exception selects the alternate interest-cover calculation and supplies the applicable clause identifier” is testable.

The second pass is operational. Assign tasks to workers, deterministic services or people, then project only cross-boundary dependencies into communication edges. Two tasks owned by one worker may need no message. Two branches that share an authoritative evidence store may exchange references rather than summaries. A high-criticality claim may require an extra verifier edge even when the base task graph contains only one producer. The communication graph is therefore a compiled implementation of the task graph, not its visual copy.

For each proposed edge, write a small contract: sender and receiver identities; permitted artefact type; acceptance and rejection rules; maximum calls or rounds; timeout and retry behaviour; provenance fields; and the state change, if any, that receipt permits. The contract makes topology observable. Without it, a line in a diagram can mean a queue, shared memory, a free-form chat, a tool call or ambient access to the same workspace. Those mechanisms have different costs and failure modes.

The compiler may emit a hybrid. That does not license an arbitrary mesh. It means the dominant relation is selected locally. A hierarchical dossier may contain a star-shaped evidence collection branch and a short chain for deterministic calculations. A dynamic branch may choose among pre-approved specialists, then return to a static synthesis point. Each region keeps its own baseline and stop condition.

An edge is approved only when removing it causes a predicted, decision-relevant failure. This is the communication equivalent of an ablation. If removing a direct agent-to-agent link changes nothing, the edge is ornamental. If replacing a natural-language message with a typed artefact preserves performance, prefer the typed artefact.

Figure 5. Wrong topology produces characteristic failures. Illustrative matrix. Green marks a plausible fit, saffron a conditional or wasteful choice, and coral a likely structural mismatch. Local testing must replace these qualitative expectations with measured outcomes.

Two controlled thought experiments

Thought experiment one: keep the team, change the dependency

Give four equally capable agents the same tool set. In Task A, four independent databases must be searched and their results deduplicated. A star with parallel spokes fits. In Task B, each result changes the query sent to the next database. A chain or bounded dynamic route fits. In Task C, the databases contain conflicting claims about one event and each has different provenance. Independent evidence packets followed by adjudication may justify debate.

The agents did not change. Only the dependency changed. The predicted measurements also change. Task A should reward branch coverage and wall-clock parallelism. Task B should reward preservation of intermediate state and penalise stale downstream queries. Task C should reward detection of unsupported claims, but only when provenance differs. If one fixed topology wins all three tasks, either it is paying unnecessary coordination cost on at least one task or the evaluator is too weak to expose the mismatch.

Thought experiment two: keep the dependency, change the authority

Use the same star for a reimbursement case. Four spokes extract receipts, policy rules, trip dates and arithmetic; the hub proposes an outcome. In Version A, the system produces a draft for a person. In Version B, the hub can issue payment. The communication topology is identical, but the authority graph is not. Version B needs authenticated identity, policy gates, value limits, idempotency, approval rules and effect readback. Adding those controls does not make the star more intelligent; it makes the action boundary governable.

This isolates a common confusion. Topology determines who can inform whom. Authority determines who can cause what. An architecture review that shows only one combined graph cannot tell whether an evidence edge silently became an execution path.

The causal prediction is precise. Adding payment authority should not improve extraction accuracy or policy interpretation. It should change only the consequence distribution and the controls required around execution. If the architecture team argues for broader tool permissions because the star “needs autonomy”, it has moved from a communication claim to an authority claim without supplying new task evidence.

Part IV

How the claim changes under pressureChart · state

stateDiagram-v2
  [*] --> Claim
  state "Precedence" as Claim
  state "Aggregation" as Test
  state "Allocation" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

The revision loop begins with Precedence and keeps counterexamples inside the reasoning path. Reading use: follow the relation, then test it against the surrounding evidence and limits.

Worked examples: from a small chain to a bounded hybrid

Minimal worked example: a warranty claim packet

A synthetic warranty packet contains a purchase receipt, product serial number, fault description and policy table. The required output is a reviewable eligibility draft. The task graph has four stages: extract fields, validate identity and date, calculate warranty age, apply policy and draft. The stages are ordered, each can emit a typed object, and no stage needs to reinterpret an earlier source after a valid handoff.

A chain is the first candidate. Yet the matched baseline is even simpler: one agent can call deterministic extraction and calculation functions, then draft. The multi-agent chain is justified only if separate context, ownership or independent validation improves a measured outcome. This is the negative control many multi-agent demonstrations omit. Splitting one prompt into four personas does not prove the task needed four agents.

Inject three failures. Return a malformed serial-number object: the next stage must reject rather than infer. Reverse the policy table's date rule: the policy stage changes while extraction remains stable. Repeat the execution request: because the system only drafts, there is no external effect to duplicate. These tests reveal the chain's benefit, local failure and replay, without granting it credit for work performed by deterministic tools.

Production-shaped worked scenario: a credit renewal dossier

Consider a synthetic commercial-credit renewal. The system assembles a dossier, not a decision. Inputs include financial statements, facility terms, covenant history, sector evidence, customer correspondence and policy obligations. The accountable credit officer retains the decision.

The task graph contains three parallel evidence branches: financial calculation, relationship and event reconstruction, and sector or external evidence. Each branch has internal sequence. A policy branch reads selected outputs and tests eligibility and exceptions. An independent verifier challenges unsupported claims and arithmetic. A lead assembler integrates evidence into a typed argument map. The human officer reviews the claims, exceptions and unresolved contradictions.

A flat star is tempting, but the branches are themselves multi-stage and deserve bounded local context. A pure hierarchy is also insufficient because the verifier must inspect evidence across branches without inheriting their assumptions. The resulting communication structure is a hierarchy with a lateral verification edge and central synthesis. The authority graph is smaller: model workers propose evidence and draft language; deterministic services calculate; the officer approves; a separate banking system executes any later change under its own controls.

The topology can change during evidence acquisition, but only inside a static envelope. If a covenant breach is detected, the policy branch may activate a legal-obligation specialist. If no breach exists, that route remains dormant. The runtime event is logged as “condition met, route activated”, not hidden inside an agent's prose. The activated specialist receives evidence access, not decision authority.

Run the selection logic against this scenario. Parallel breadth is high, but so are recursive decomposition and branch depth. Cross-branch coupling is limited to named policy and verification points, so a complete mesh would be wasteful. Path uncertainty is moderate rather than dominant because only a few evidence conditions activate alternate specialists. The hierarchy therefore wins as the base topology, with one lateral verifier and one bounded dynamic route. This explanation matters more than the numerical score: it identifies which future change would require recompilation. If legal findings begin to revise financial assumptions repeatedly, the local relation becomes reciprocal and the static envelope needs a tested feedback loop.

Figure 6. The production-shaped example is a hybrid because the task is hybrid. Synthetic scenario. Evidence work forms three bounded subtrees, central synthesis creates the dossier, and a lateral verifier crosses branches. Human decision and execution remain on a separate authority path.

Executable artefact: a transparent topology selector

The companion selector is deliberately rule-based. It is not a learned recommender and its scores are not empirical performance estimates. Its purpose is to force a design team to state task properties on a small ordinal scale, show which rules fired, compare six multi-agent shapes with a single-agent baseline, and preserve a negative case where debate should lose.

The positive cases require a typed document pipeline to select a chain, an independent claim adjudication to select debate, and the credit-renewal dossier to select a hierarchy. The negative control describes a simple task where nominal “debaters” share the same evidence. The selector must prefer one worker and score debate below it.

Open the complete runnable Python selector

Assumptions. Python 3.10 or later, no third-party packages, synthetic profiles only. Save as topology_selector.py and run python3 topology_selector.py.

"""Rule-based topology selector for synthetic design exercises.

Python 3.10+. Standard library only.
The scores are explicit design weights, not empirical performance estimates.
"""
from __future__ import annotations

from dataclasses import dataclass, fields
from typing import Callable


@dataclass(frozen=True)
class TaskProfile:
    name: str
    complexity: int                  # 0 simple, 1 moderate, 2 high
    fixed_sequence: int              # ordered typed stages
    parallel_branches: int           # conditionally independent work streams
    recursive_decomposition: int     # tasks contain similar subtask trees
    provider_substitutability: int   # several workers could do the same task
    bid_quality_observable: int      # cost/quality can be compared before award
    competing_hypotheses: int        # same proposition needs adversarial testing
    evidence_independence: int       # agents can obtain genuinely different evidence
    path_uncertainty: int            # next useful task depends on intermediate findings
    reciprocal_coupling: int         # branches must repeatedly revise one another
    central_synthesis: int           # one node must integrate outputs
    high_consequence_authority: int  # actions can create material external effects
    typed_handoffs: int              # interfaces can be schema-validated

    def __post_init__(self) -> None:
        for f in fields(self):
            if f.name == "name":
                continue
            value = getattr(self, f.name)
            if value not in (0, 1, 2):
                raise ValueError(f"{f.name} must be 0, 1, or 2; got {value!r}")


@dataclass(frozen=True)
class Result:
    topology: str
    score: int
    reasons: tuple[str, ...]
    cautions: tuple[str, ...]


def add(points: int, condition: int, reason: str, bucket: list[str]) -> int:
    if condition:
        bucket.append(reason)
    return points * condition


def score(profile: TaskProfile, topology: str) -> Result:
    r: list[str] = []
    c: list[str] = []
    s = 0

    if topology == "single":
        s += add(4, int(profile.complexity == 0), "task is simple", r)
        s += add(2, int(profile.parallel_branches == 0), "no parallel branches", r)
        s += add(2, int(profile.competing_hypotheses == 0), "no independent contest is required", r)
        s -= add(3, profile.path_uncertainty, "open path exceeds one worker's bounded context", c)
        s -= add(2, profile.recursive_decomposition, "recursive work creates separable ownership", c)

    elif topology == "chain":
        s += add(4, profile.fixed_sequence, "ordered stages dominate", r)
        s += add(3, profile.typed_handoffs, "handoffs can be validated", r)
        s += add(1, int(profile.parallel_branches == 0), "little parallelism is available", r)
        s -= add(4, profile.reciprocal_coupling, "mutual revision breaks a one-way path", c)
        s -= add(3, profile.path_uncertainty, "the next stage cannot be fixed safely", c)

    elif topology == "star":
        s += add(4, profile.parallel_branches, "independent branches can run around a hub", r)
        s += add(3, profile.central_synthesis, "one integrator must reconcile outputs", r)
        s += add(1, profile.typed_handoffs, "spoke outputs can be normalised", r)
        s -= add(3, profile.reciprocal_coupling, "spokes need direct mutual adjustment", c)
        s -= add(2, profile.recursive_decomposition, "one hub becomes a scaling bottleneck", c)

    elif topology == "hierarchy":
        s += add(5, profile.recursive_decomposition, "the task decomposes into bounded subtrees", r)
        s += add(2, profile.parallel_branches, "subtrees can progress concurrently", r)
        s += add(2, profile.central_synthesis, "local summaries can roll upward", r)
        s += add(2, profile.high_consequence_authority, "authority can narrow toward the root", r)
        s -= add(3, profile.reciprocal_coupling, "cross-subtree negotiation defeats clean boundaries", c)

    elif topology == "market":
        s += add(5, profile.provider_substitutability, "multiple providers can perform comparable work", r)
        s += add(4, profile.bid_quality_observable, "award criteria are observable before execution", r)
        s += add(1, profile.parallel_branches, "allocations can proceed independently", r)
        s -= add(4, profile.reciprocal_coupling, "coupled tasks cannot be priced independently", c)
        s -= add(2, profile.high_consequence_authority, "winning a bid must not inherit ambient authority", c)

    elif topology == "debate":
        s += add(5, profile.competing_hypotheses, "the same proposition needs structured contest", r)
        s += add(5, profile.evidence_independence, "participants can bring non-identical evidence", r)
        s += add(1, profile.central_synthesis, "a judge or rule can resolve disagreement", r)
        s -= add(4, int(profile.evidence_independence == 0), "agents would echo the same evidence", c)
        s -= add(2, profile.fixed_sequence, "the work is decomposable rather than contestable", c)

    elif topology == "dynamic":
        s += add(5, profile.path_uncertainty, "useful edges depend on intermediate findings", r)
        s += add(3, profile.reciprocal_coupling, "participants must adapt to one another", r)
        s += add(1, profile.parallel_branches, "the active frontier can widen or contract", r)
        s -= add(3, profile.high_consequence_authority, "runtime rewiring enlarges assurance debt", c)
        s -= add(2, profile.typed_handoffs, "a static graph may already express the known contract", c)

    else:
        raise KeyError(topology)

    return Result(topology, s, tuple(r), tuple(c))


TOPOLOGIES = ("single", "chain", "star", "hierarchy", "market", "debate", "dynamic")


def choose(profile: TaskProfile) -> list[Result]:
    return sorted((score(profile, t) for t in TOPOLOGIES), key=lambda x: (-x.score, x.topology))


def print_case(profile: TaskProfile) -> None:
    ranked = choose(profile)
    best = ranked[0]
    print(f"\n{profile.name}: {best.topology} ({best.score})")
    print("  because:", "; ".join(best.reasons) or "no positive rule fired")
    if best.cautions:
        print("  cautions:", "; ".join(best.cautions))
    print("  ranking:", ", ".join(f"{x.topology}={x.score}" for x in ranked))


CASES = (
    TaskProfile(
        name="typed document pipeline",
        complexity=1, fixed_sequence=2, parallel_branches=0,
        recursive_decomposition=0, provider_substitutability=0,
        bid_quality_observable=0, competing_hypotheses=0,
        evidence_independence=0, path_uncertainty=0,
        reciprocal_coupling=0, central_synthesis=1,
        high_consequence_authority=0, typed_handoffs=2,
    ),
    TaskProfile(
        name="independent claim adjudication",
        complexity=2, fixed_sequence=0, parallel_branches=1,
        recursive_decomposition=0, provider_substitutability=0,
        bid_quality_observable=0, competing_hypotheses=2,
        evidence_independence=2, path_uncertainty=0,
        reciprocal_coupling=1, central_synthesis=2,
        high_consequence_authority=1, typed_handoffs=1,
    ),
    TaskProfile(
        name="correlated echo negative control",
        complexity=0, fixed_sequence=0, parallel_branches=0,
        recursive_decomposition=0, provider_substitutability=0,
        bid_quality_observable=0, competing_hypotheses=1,
        evidence_independence=0, path_uncertainty=0,
        reciprocal_coupling=0, central_synthesis=1,
        high_consequence_authority=0, typed_handoffs=1,
    ),
    TaskProfile(
        name="credit renewal dossier",
        complexity=2, fixed_sequence=1, parallel_branches=2,
        recursive_decomposition=2, provider_substitutability=0,
        bid_quality_observable=0, competing_hypotheses=1,
        evidence_independence=1, path_uncertainty=1,
        reciprocal_coupling=0, central_synthesis=2,
        high_consequence_authority=2, typed_handoffs=2,
    ),
)


if __name__ == "__main__":
    for case in CASES:
        print_case(case)

    # Positive cases.
    assert choose(CASES[0])[0].topology == "chain"
    assert choose(CASES[1])[0].topology == "debate"
    assert choose(CASES[3])[0].topology == "hierarchy"

    # Negative control: duplicating a simple worker without independent evidence
    # must not make debate the preferred architecture.
    negative = choose(CASES[2])
    assert negative[0].topology == "single"
    assert next(x for x in negative if x.topology == "debate").score < negative[0].score
    print("\nAll positive cases and the negative control passed.")

Recorded output from the supplied cases

typed document pipeline: chain (15)
  ranking: chain=15, star=5, single=4, hierarchy=2, market=0, dynamic=-4, debate=-7

independent claim adjudication: debate (22)
  ranking: debate=22, star=8, hierarchy=5, single=0, chain=-1, dynamic=-1, market=-5

correlated echo negative control: single (6)
  ranking: single=6, chain=4, star=4, debate=2, hierarchy=2, market=0, dynamic=-2

credit renewal dossier: hierarchy (22)
  ranking: hierarchy=22, star=12, debate=10, chain=7, market=-2, dynamic=-3, single=-7

All positive cases and the negative control passed.

Figure 7. A selector earns trust by rejecting unnecessary coordination. Synthetic scores generated by the included Python artefact. The negative control prefers a single worker because additional debaters have no independent evidence.

Failure boundary and strongest competing explanation

Topology cannot rescue a bad task definition. If the final decision is vague, node outputs are untestable, tools are unreliable or evidence is unavailable, a more elaborate graph only distributes ambiguity. Topology also cannot manufacture cognitive diversity from identical training, prompts and sources. Nor does a dynamic route create permission, provenance or recovery by itself.

The strongest competing explanation is that observed gains come mainly from more model calls, tokens, tools or search effort rather than the interaction structure. Anthropic's engineering analysis, for example, reports that token use explained much of performance variance in one browsing evaluation.⁹ Agent evaluation research likewise warns that needlessly complex systems can appear superior when cost, holdouts and reproducibility are weak.¹⁵

This alternative must be tested, not dismissed. Match total model and tool budgets. Compare a single agent, parallel independent sampling, the proposed topology and a complete communication graph. Measure task quality, latency, cost, variance, recovery and authority exposure. If the topology does not outperform the cheaper baseline on the decision-relevant frontier, remove it. The claim is weakened whenever structure adds conversation but not new evidence, better allocation, safer authority or faster recovery.

Four observations should force redesign rather than prompt tuning. First, the proposed topology loses to a one-worker baseline after budget matching. Second, errors remain correlated across agents despite nominal roles, so debate and voting add confidence without information. Third, recovery requires replaying the whole team because intermediate artefacts and routing decisions were not persisted. Fourth, a communication edge can trigger an external effect without an independently checked authority transition. These are architectural falsifiers. They show that the graph is unnecessary, epistemically weak, operationally opaque or unsafe at its boundary.

There is also a scale boundary. In partially observable decentralised decision problems, exact joint planning can become computationally severe, and adding agents can enlarge the policy space rather than simplify it.⁷ The practical response is not to imitate the full formal problem with more conversation. Reduce the state each worker needs, centralise a dependency when that is acceptable, use deterministic allocation where bids add no value, or bound dynamic routing to a small authorised subgraph. Simplicity is not the absence of intelligence. It is the removal of coordination work that has no causal job.

Serious negative control. Duplicate the same model, prompt, tools and evidence three times, then allow full debate. If performance rises only when total tokens rise, or if independent sampling performs as well, the debate edges have not demonstrated a coordination mechanism.

Source notes and evidence ledger

Primary theory. Thomas W. Malone and Kevin Crowston, The Interdisciplinary Study of Coordination. The paper frames coordination around dependencies among activities.
Primary survey. Bryan Horling and Victor Lesser, A Survey of Multi-Agent Organizational Paradigms. It compares organisational forms and their trade-offs.
Primary architecture. H. Penny Nii, The Blackboard Model of Problem Solving and the Evolution of Blackboard Architectures.
Primary protocol. Reid G. Smith, The Contract Net Protocol.
Primary framework paper. Qingyun Wu and colleagues, AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation.
Primary research. Mingchen Zhuge and colleagues, GPTSwarm: Language Agents as Optimizable Graphs.
Primary formal result. Daniel S. Bernstein and colleagues, The Complexity of Decentralized Control of Markov Decision Processes.
Primary framework paper. Sirui Hong and colleagues, MetaGPT: Meta Programming for a Multi-Agent Collaborative Framework.
Official engineering source. Anthropic, How We Built Our Multi-Agent Research System. Used as a bounded implementation account, not general scientific evidence.
Official specification. Foundation for Intelligent Physical Agents, FIPA Contract Net Interaction Protocol Specification.
Primary research. Yilun Du and colleagues, Improving Factuality and Reasoning in Language Models through Multiagent Debate.
Primary negative and comparative result. Andries Petrus Smit and colleagues, Should We Be Going MAD?
Primary systematic evaluation. Hangfan Zhang and colleagues, If Multi-Agent Debate Is the Answer, What Is the Question?
Primary research. Zijun Liu and colleagues, A Dynamic LLM-Powered Agent Network for Task-Oriented Agent Collaboration.
Primary evaluation critique. Sayash Kapoor and colleagues, AI Agents That Matter.
Recent primary preprint. Yubin Kim and colleagues, Towards a Science of Scaling Agent Systems. Used for controlled, benchmark-specific evidence that architecture and task structure interact.
Recent primary preprint. Mao-xun Huang and colleagues, MANTA: Multi-Agent Network Topology Adaptation for Self-Evolving Multi-Agent Systems. Used as bounded evidence for task-conditioned, inference-time topology updates.

Conclusion

The evidence conversationChart · sequence

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: Six specialists, one reusable mistake
  M->>E: Precedence
  E-->>M: compare rival explanations
  E->>D: Stop drawing the team before drawing the work
  D-->>Q: revise scope or act

Question, mechanism, evidence and decision exchange the burdens developed in Choosing Topology from Task Structure. Reading use: follow the relation, then test it against the surrounding evidence and limits.

Stop drawing the team before drawing the work

The architecture decision changes at the first whiteboard. Do not begin with six agent icons and decide how to connect them. Begin with the decision, the artefacts and the dependencies. Mark which activities must precede, aggregate, allocate, contest or revise. Ask whether one worker and deterministic tools can already manage them. Only then project the minimum communication graph.

A chain earns its place through stable precedence. A star through independent branches and central synthesis. A hierarchy through recursive modularity. A market through substitutable providers and observable bids. Debate through independent evidence about one contested proposition. A dynamic graph through path uncertainty that genuinely changes the useful team. None is a maturity level. None is universally more agentic.

The defensible topology is the one whose edges can each answer four questions: which dependency requires me, what artefact crosses me, what failure appears when I am removed, and why do I carry no more authority than the task demands? When those answers are absent, the graph is decoration. When they are explicit, topology becomes an experimental claim that can be ablated, costed, contained and improved.