If you're building a team of AI agents, should they work in a line, critique each other, or split up and work at once?
How should designers choose between pipeline, critique loop, or swarm coordination?
This explores how someone building a multi-agent AI system should decide between three ways of organizing it: a pipeline where agents hand off work in sequence, a loop where one agent critiques another's output, or a swarm where a coordinator sends tasks to many agents working in parallel.
This explores how to pick between three ways of organizing AI agents: handing work down a line, having one agent critique another, or sending pieces out to many agents at once. The three forms come from What organizational patterns work best for multi-agent coordination?, who compares them to how human teams work. Pipelines suit simple tasks with clear handoffs. Critique loops suit work where quality comes from repeated revision. Swarms led by a coordinator suit work that can run in parallel. The catch with swarms is that they assume the work splits cleanly into separate pieces, and that assumption is where most of the trouble starts.
The strongest warning about swarms comes from Why do parallel subagents produce conflicting design decisions?. Every action an agent takes rests on small assumptions it never writes down. When agents work in parallel, they can't see each other's assumptions, so they make choices that conflict. Yan's advice is to go back to one agent working through the task in order. Research on reasoning points the same way: When does sequential reasoning beat parallel voting? shows that when each step depends on the last one, working through steps in order beats running many short attempts in parallel and voting, by an exponential margin. So the first question to ask is whether the parts of the task really are independent. If later work depends on earlier results, splitting it up costs more than it saves.
The second question is whether you need multiple agents at all. When should teams choose workflows over agents? says to start with a single well-designed call or a fixed workflow, which is basically a pipeline. Move to agents only when you can't predict the path the task will take. On the other side, Do single agents always hit organizational limits? argues that some tasks really do outgrow one agent: ones that need different kinds of expertise, parallel execution, or a separate checker. A separate checker is exactly what a critique loop provides. There's also a benefit to critique that's easy to miss. Do critique models improve diversity during training itself? finds that step-by-step critique keeps a model's solutions varied instead of letting them narrow too early. So critique loops can protect the range of solutions an agent considers, not just catch its mistakes.
Organizational theory has studied this tradeoff for decades. How do coordination architectures trade off efficiency against resilience? summarizes Malone and Crowston's models. Centralized control, which is roughly what a swarm's coordinator provides, is cheap to coordinate but breaks when a key part fails. Decentralized setups survive failures but cost a lot to coordinate. Hierarchies sit in between and leave some capacity unused. No option wins on every dimension, so the choice depends on which failure you can least afford. Sharing information can also ease the main weakness of parallel work: Does sharing experience across agents beat isolated evolution? found that agents improved much more when they pooled their code changes and execution records than when each evolved alone.
One more option: you don't have to commit to a single structure. Can multi-agent teams swap roles, coordination, and algorithms independently? and the older Can separating structure and function improve multiagent organization design? both separate who does what from how the work is coordinated, so you can swap one without rebuilding the other. And Can LLMs automatically discover better team structures than humans? goes further, using a critique loop to redesign the team itself. It found chain, dual-leader, and changing structures that beat hand-designed ones. In practice, the best way to choose a structure may be to run a critique loop over a few candidates and let it find the right one.
Sources 11 notes
Josh Clark identifies three multi-agent forms analogous to human work: pipeline hand-offs for simple tasks, critique-driven loops for quality refinement, and conductor-led swarms for parallel work. Swarms trade sequential order for speed but assume tasks can be cleanly compartmentalized—an assumption contested by research on context fragmentation.
Walden Yan argues multi-agent parallelism is fundamentally fragile: subagents embed unwritten assumptions in every action, so agents working independently converge on conflicting choices. The fix is reverting to single-threaded linear agents where context remains continuous.
On structured tasks requiring sequential multi-step reasoning like graph connectivity, chain-of-thought achieves exponentially higher accuracy than parallel voting. The difference emerges because solutions genuinely require accumulating intermediate results sequentially, which short parallel chains cannot achieve.
Anthropic recommends a simplicity-first discipline: optimize single LLM calls and workflows for decomposable tasks before adopting agents, since agents trade latency and cost for flexibility only when task paths cannot be predetermined.
Research shows that real-world tasks requiring heterogeneous expertise, parallel execution, and independent verification exceed what any single agent loop can organize. Graph-based system abstractions are needed to distribute intelligence across specialized agents.
Show all 11 sources
Step-level critique in the training loop counteracts tail narrowing and maintains solution diversity across self-training iterations. This training-time benefit—preventing premature convergence—is more fundamental than test-time accuracy gains.
Malone and Crowston's formal models show centralized schemes minimize coordination costs but fail under processor failures, decentralized markets resist failures but incur high coordination costs, and hierarchies reduce coordination costs while creating unused capacity. Each architecture optimizes one dimension at the expense of others.
Group-Evolving Agents outperformed isolated tree-based self-evolution by 14–20 percentage points by explicitly pooling code patches and execution traces within each generation. Analysis showed five of eight key tool improvements came from different parent agents, proving the sharing mechanism itself—not just more search—drove the gains.
IMACS demonstrates that team structure (Belbin roles), coordination mechanism (Mintzberg framework), and fusion algorithm can be architecturally separated into independent components. This decoupling lets teams and protocols swap without rewriting each other, unlike existing frameworks that fuse these concerns together.
Hübner, Sichman, and Boissier's 2002 model splits organizational specification into structural (roles and groups), functional (global plans), and deontic (permissions and obligations) dimensions. This separation avoids failures where agents lack guidance or lose validated plans.
A Criticize-Reflect loop using LLM critique and reflection iteratively rewrites organizational prompts, discovering chain, dual-leader, and dynamic team structures that beat hand-designed alternatives on time and communication metrics in VirtualHome tasks.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures
- Towards a Science of Scaling Agent Systems
- Worse Together: How Performance Breaks Down in Multi-User Multi-Agent Teams
- Toward an Organizational Science of Multi-Agent LLM Systems: Decoupling Who, How, and Which Algorithm
- Embodied LLM Agents Learn to Cooperate in Organized Teams
- Why Do Multi-agent LLM Systems Fail?
- Towards a Science of AI Agent Reliability
- AgentsNet: Coordination and Collaborative Reasoning in Multi-Agent LLMs