Topologies

In one line: who talks to whom is the architecture, and the shapes differ by an order of magnitude in what coordination costs.

The five shapes

Pipeline. Agents in a fixed sequence, each consuming the previous one's output. Zero parallelism, simple to reason about, and — as the previous lesson argued — usually better described as a workflow.

Supervisor and workers. A star. One component decomposes, dispatches, and decides when the goal is met; workers do their piece and return. Edges grow linearly with the number of workers.

Mesh. Every agent can talk to every other. Maximally flexible, no single point of failure, and edges grow quadratically — which is why these degrade quickly past a handful of participants and are rare in production.

Debate. Several agents answer independently, then see each other's answers and revise. Useful where independent judgements genuinely help, and it needs a mandatory stop condition or it iterates forever.

Blackboard. A shared structured state that agents read from and write to, rather than messaging each other. Decouples participants, and it moves the coordination problem into managing concurrent access to shared state.

Why the star wins

Three reasons, and they are all about failure rather than elegance.

One component owns the goal. Someone has to decide the task is finished, and distributing that produces a system where nobody can answer whether it did. The supervisor is that answer.

One component owns the budget. Total steps and total spend allocated from one place is what bounds a system whose participants would otherwise each spend independently.

Attribution is tractable. When the output is wrong, a star has a small number of edges to inspect. A mesh has a conversation, and reconstructing which exchange introduced the error is genuinely hard.

The cost is the obvious one: the supervisor is a bottleneck and a single point of failure, and every dispatch costs a model call. That is a real price and it is usually worth paying.

Coordination latency is real

The cost people underestimate, and it is worth putting numbers on.

Every level of hierarchy adds a model call before any work begins. A supervisor deciding what to dispatch is a call; a sub-supervisor deciding within its group is another. With calls of a second or two, a three-level structure spends several seconds on organisation before a worker starts, and a four-level one more.

So depth is expensive in a way breadth is not. Prefer wide and shallow to narrow and deep — one supervisor with five workers costs one coordination call; three levels of two costs three, sequentially, before anything useful happens.

That is a direct argument against the organisational-chart instinct. Human hierarchies are deep because a manager's span of attention is limited. A supervisor's is not, so the reason for depth does not transfer.

When debate is worth it

The shape with the most enthusiasm and the narrowest application.

It helps when the sub-problem genuinely benefits from independent judgements that are then reconciled — an ambiguous classification, an estimate, a decision with real uncertainty. Several independent answers carry more information than one, and letting each see the others surfaces disagreement that a single pass hides.

It does not help on tasks with a determinate answer, where it converts one call into several plus a reconciliation step and mostly produces agreement.

Two design requirements if you use it. The first round must be genuinely independent — agents that see each other's answers before committing produce correlated ones, and the independence is where the value is. And there must be a hard stop, because iterative refinement without one is a loop with no termination condition, which the single-agent chapter established is a hope rather than a design.

The blackboard, briefly

Worth knowing because it appears in real systems and solves a specific problem.

Instead of agents messaging each other, they read and write a shared structured state. A worker publishes what it learned; others pick it up when relevant. That decouples participants — an agent does not need to know who needs its output — and it makes the system's state inspectable in one place, which helps enormously with debugging.

The cost is that shared mutable state has all its usual problems: concurrent writes, stale reads, and agents acting on a version that has since changed. Which is a familiar distributed-systems problem rather than a novel one, and treating it as such — with a schema, versioning and explicit conflict handling — is the right response.

It is a reasonable choice when the set of participants changes at runtime, and over-engineering when it does not.

Choosing

The decision, compactly.

And the meta-point worth carrying: the topology is a coordination decision, and coordination is the largest failure category. Choosing the simplest shape that meets the requirement is not conservatism here — it is directly attacking where these systems actually break.

Next: what actually passes between agents.