Match each multi-agent topology to its defining coordination property

Match pairs·Medium·4.0 · 0·~2 min·Asked atCitadel Neo4j Zepto

Attempt it

Drag each answer to line up with its matching prompt

Supervisor and workers

Multiple agents argue from different positions and a final round picks or synthesises the winner

Peer swarm

Agents take turns in a fixed cyclic order regardless of who is best suited

Round robin

Agents transfer control to each other via handoff tool calls with no central manager

Debate or council

Agents read and write a shared structured workspace; an external scheduler decides who runs next

Blackboard

A central manager agent picks which worker runs next after each hop

Market or auction

Agents bid on tasks and the coordinator awards work to the highest confidence or lowest cost bidder

**Multi-agent topologies** differ on one decisive question: who decides which agent runs next? The six in the pairing exercise each give a different answer. **Supervisor and workers.** A central manager agent reads the task, picks a worker, hands off, reads the worker's result, picks again. Centralised decision-making. Predictable traces. Used by LangGraph's `create_supervisor`, CrewAI hierarchical Process, and AutoGen's Selector group chat. **Peer swarm.** No central manager. Each agent decides when to hand off control to another agent via a handoff tool call. Flexible and lower-overhead per turn; harder to reason about and prone to loops. Used by OpenAI's Agents SDK (the canonical implementation) and LangGraph swarm prebuilt. **Round-robin.** Agents take turns in a fixed cyclic order. Nobody decides; the order does. Trivial to implement; ignores the routing problem entirely. AutoGen's `RoundRobinGroupChat` is the canonical example. **Debate or council.** Multiple agents argue from different positions; a final round picks the winning answer or synthesises a position. Used for self-consistency, red-teaming, and adversarial fact-checking. The decision is the argument's outcome, not a single agent's pick. **Blackboard.** Agents read and write a shared structured workspace. An external scheduler decides who runs next based on what is on the blackboard (which fields are filled, which are missing). Classic AI architecture; modern revival as LangGraph shared state. **Market or auction.** Agents bid on tasks; a coordinator awards the work to the highest-confidence or lowest-cost bidder. Theoretically clean; cost-prohibitive in production because each bid is an LLM call. The matching exercise tests whether you can read each topology's description and recognise its decision-making centre.

**Each topology compresses a different opinion about who decides which agent runs next.** That single question separates them cleanly. **Supervisor and workers** centralises the decision in a manager. The supervisor picks each hop, reads the result, picks again. Implemented in LangGraph `create_supervisor`, CrewAI hierarchical Process, AutoGen `SelectorGroupChat`. **Peer swarm** distributes the decision to each agent. An agent runs until it transfers control via a handoff tool call. No central manager. Lower per-turn overhead; harder to reason about cycles. OpenAI's Agents SDK is canonical. **Round-robin** removes the decision. Agents cycle through a fixed order. AutoGen's `RoundRobinGroupChat` is the example. **Debate or council** is decision by argument. Agents present positions (sequentially in debate, in parallel in council) and a final round synthesises. The decision is whichever position wins. **Blackboard** uses an external scheduler reading a shared workspace. Agents read and write; the scheduler picks the next agent based on which fields need filling. Data-driven, not agent-driven. **Market or auction** awards work to bidders. Agents bid; a coordinator picks the winner. Theoretically elegant; cost-prohibitive because every bid is an LLM call. The matching task lines up each topology with its decision mechanism. Common mistakes: conflating supervisor with blackboard (both have a coordinator but read different signals) or peer swarm with round-robin (both lack a manager but route very differently).

TL;DR

Six topologies differ by who decides who runs next: supervisor (manager), swarm (peers), round-robin (order), debate (argument), blackboard (state), market (bid).

Memory aid

Easy to grasp

Imagine a group project. A supervisor topology is one student playing project manager: 'You do the slides, you do the research, you write the conclusion'. A peer swarm is no project manager: students just hand work to whoever is best for the next part. Round-robin is going around the table in order regardless of skill. Debate is everyone making the case for their idea before voting. Blackboard is a shared whiteboard where someone outside the group checks what is written and assigns the next task. Market is everyone bidding 'I can do that part for one cookie' and the lowest bidder wins. Same goal, six very different ways to coordinate.

Key concepts

Multi-Agent Systems

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Multi-agent topologies look like a long taxonomy in textbooks and a confused list of buzzwords in practice. The cheapest way to make sense of all six is to ask one question of each: who decides which agent runs next? The answers map cleanly onto six distinct mechanisms, and once you can name the mechanism for each topology, the matching exercise becomes a five-second pattern recognition.

The interview value is design-space literacy. New topologies will keep appearing through 2026 and beyond; each new one can be slotted into the taxonomy by asking the same decisive question. The pattern travels.

Mental model: six topologies, six different answers to 'who decides who runs next'.

The centralised and distributed pair: supervisor and swarm

Supervisor and workers

A central manager agent makes the routing call. The supervisor reads the task and the running state, picks a worker, hands off, reads the worker's result, picks again. The decision-making is centralised in one place; the trace shows 'supervisor decided worker A, supervisor decided worker B' as discrete events you can audit.

Production examples: LangGraph's create_supervisor prebuilt, CrewAI's hierarchical Process with manager_llm, AutoGen's SelectorGroupChat (which is a supervisor with LLM-based speaker selection).

Strength: predictable, traceable, structured. Weakness: every hop costs one supervisor LLM call on top of the worker call, which can dominate latency and cost in hot paths.

Peer swarm

The routing decision is distributed to the agents themselves. Each agent runs until it decides another agent is better suited and emits a handoff tool call. No central manager. The framework intercepts the handoff and swaps the active agent.

Production examples: OpenAI's Agents SDK (the canonical 2026 implementation), LangGraph's swarm prebuilt, smolagents' multi-agent mode.

Strength: lower per-turn cost (no supervisor call), more flexible routing because each agent's decision can incorporate context the supervisor would not have. Weakness: routing logic is spread across all agents, cycles are harder to reason about, deadlock becomes possible (the topology where the watchdog pattern earns its keep).

The no-decision and decision by argument pair: round-robin and debate

The data-driven and market pair: blackboard and auction

Using the taxonomy as a decision tool

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

LangGraph ships create_supervisor (supervisor topology) and create_swarm (peer swarm) as the two dominant prebuilts.
OpenAI's Agents SDK is the canonical peer-swarm implementation with handoff as tool call as the primitive.

What an interviewer would ask next. Try answering before peeking at the approach.

QSketch a workflow where you would deliberately pick blackboard over supervisor, and explain the tradeoff.

Multi-source data extraction where several agents fill different fields in a structured output (one agent extracts company name, another extracts financials, another extracts board members) and the scheduler watches which fields are still empty. Blackboard wins because the routing decision is data-driven (which field is empty) rather than judgement-driven, and the parallel filling is natural. Supervisor would add an LLM call per dispatch that the data-driven scheduler avoids entirely.

1 more follow-up an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Treating topologies as interchangeable. Each one optimises for a different property (centralised control, flexibility, fairness, dissent, shared state, market efficiency); pick the property that matters for your workload.

60 second bullets to scan on the way to the call.

The 'who decides who runs next' question as the taxonomic lens
Supervisor + workers as centralised decision-making

Primary sources. Browse if you want the original framing.