Built on the Vercel AI SDK
Nine ways to make AI agents work as a team
The same request, solved by nine different multi-agent architectures — from a single coordinator delegating to specialists, to peers negotiating on a bus, to a market where agents bid for work. Watch them think, stream live, and see what each pattern costs.
This is a public demo — bring your own OpenAI or Anthropic API key in Settings to run it.
About
“Multi-agent” gets used as one word, but there are many distinct ways to coordinate agents — and they behave very differently. This is a place to feel the differences: run the same task through each architecture, watch the live agent timeline, inspect every tool call and message in the debug stream, and compare cost. It’s a teaching tool and a reference implementation in one.
Agentic AI moves fast — new patterns, frameworks, and papers land every week. The goal here is a living reference: a single place to learn the coordination patterns by running them, with the research and source for each one a click away.
Contributions welcome. Know a pattern, paper, or framework that belongs here? Add it — open a PR with a new architecture or a reference, or file an issue. The patterns are data-driven, so adding one is mostly a new runner + a mode entry.
The nine architectures
Open any architecture for how it works, the agents, notes, and references.
coordinator + research / write / edit
Best for: Linear content pipelines where the steps and their order are clear up front.
Trade-off: A single coordinator is a bottleneck and a single point of failure; no parallelism.
backend / frontend / design peers
Best for: Cross-functional design tasks where peers must negotiate a shared artifact.
Trade-off: Peer negotiation can loop or stall; harder to guarantee convergence than a coordinator.
a lead spawns sub-agents on the fly
Best for: Open-ended tasks that naturally break into nested, independent subtasks.
Trade-off: Emergent tree shape is less predictable; recursive spawning + synthesis costs more tokens.
generate → critique → revise, until it passes
Best for: A single artifact you want iteratively improved to a quality bar — a draft, spec, or snippet.
Trade-off: Cost grows with each round; a never-satisfied critic can burn the full round budget.
opposing sides argue, a judge decides
Best for: Decisions and trade-offs where the strongest case for each side should be heard first.
Trade-off: Adds rounds of argument before any answer; the verdict quality depends on the judge.
agents share one workspace; a controller picks who acts
Best for: Problems whose answer assembles from many partial contributions converging on a shared artifact.
Trade-off: Controller selection can loop; no direct peer messaging means coordination is slower.
agents bid on tasks; best bid wins
Best for: Heterogeneous work where the best agent for each task is not obvious up front.
Trade-off: The bid round is extra LLM calls; only worth it for larger, varied agent pools.
sample in parallel, judge the best
Best for: Questions where one attempt is noisy but agreement across attempts signals quality.
Trade-off: N parallel samples cost N× the tokens of a single attempt for the sampling step.
identical agents build on a shared scratchpad
Best for: Open-ended ideation and refinement that benefits from many cheap passes converging.
Trade-off: No structure means redundancy and drift; convergence isn’t guaranteed, so it’s round-capped.
Pick a pattern and watch it run
Switch architectures from a dropdown, stream the agents’ reasoning live, and see the cost of every step.
Launch the app