Definition: A multi-agent system is a software architecture where two or more autonomous AI agents work together on a shared task — passing context, calling each other, voting, or merging results. Multi-agent beats single-agent on hard problems because narrow specialists outperform a single generalist, and parallel exploration finds solutions a sequential agent would miss.
Why Multi-Agent
Single-agent systems hit two ceilings:
- Context window — one agent has to fit the whole problem, all the tools, all the relevant memory in one prompt. As tasks grow, this stops fitting.
- Specialization — a generalist agent good at everything is rarely the best choice. A research agent + a writing agent + an editing agent will outperform a single "all-purpose" agent for content tasks.
Multi-agent systems solve both: each agent has a narrow scope, a tight context window, and a clear hand-off rule for when to call the next agent.
Architectures
Sequential Hand-Off
Agent A finishes, hands its output to Agent B, which finishes and hands to C. Linear, predictable, easy to debug. Best when the task has clear sequential phases.
Hierarchical Orchestration
A "manager" agent decides which sub-agent to call and aggregates their answers. Flexible but introduces a choke point — the manager has to read every sub-agent's output. CrewAI and AutoGen are the open-source poster children of this pattern.
Debate / Voting
N agents propose answers; one of them (or all of them) judges which is best. Increases robustness on questions with one right answer (factual lookup, code correctness). Adds compute cost.
Interference Merge (Genesis Quantum)
Run N agents in parallel; structurally merge their outputs; commit invariants, surface divergences to the user, drop outliers. No orchestrator, no debate. See /wiki/quantum/multi-agent-interference for the full deep dive on why this scales better as compute drops.
| Architecture | Best For | Failure Mode |
|---|---|---|
| Sequential | Predictable pipelines | Bottleneck at the slowest agent |
| Hierarchical | Flexible task routing | Manager hallucinates wrong route |
| Debate / Voting | Single-answer questions | Compute cost grows superlinearly |
| Interference | Robust parallel exploration | Requires structural alphabet (Workspace DNA) |
Taskade's Multi-Agent Primitives
Taskade ships multi-agent as a first-class workspace feature, not an external framework you bolt on:
- Agent teams — group multiple agents into a named team with a shared brief
- Cross-agent calls — any agent can call another agent (with workspace permission checks)
- Shared Project memory — all agents in a team read and write the same Project, building cumulative context
- Public agents with internal-piece filtering — share agents externally without leaking workspace tools
- Multi-agent collaboration with shared automations — multiple agents trigger on the same event and contribute pieces
For the Quantum-style parallel architecture (interference merge), see Genesis Quantum — it's the same primitives, run in parallel rather than sequentially.
When To Use Single Agent vs Multi-Agent
| Use Single Agent When | Use Multi-Agent When |
|---|---|
| Task fits in one prompt + tool list | Task has clearly distinct phases |
| Context is small | Context exceeds one window |
| Latency matters more than quality | Quality matters more than latency |
| You're prototyping fast | You've identified specific specialist roles |
| Cost is sensitive | Cost can scale with task value |
A Real Multi-Agent Workflow
Goal: Generate a competitive analysis report for a new market.
Agent 1: Researcher — calls
/websearches, reads competitor websites, extracts pricing and feature claims. Writes findings to a Project.
Agent 2: Analyst — reads the Project, scores competitors, identifies positioning gaps. Updates the Project.
Agent 3: Writer — reads the analyzed Project, drafts a report in markdown.
Agent 4: Editor — reads the draft, tightens copy, surfaces weak claims back to the Analyst (loop).Sequential hand-off; shared Project memory; runs end-to-end in 8–15 minutes; produces a 2,000-word report. Ship to Slack.
The Skill Issue
Karpathy's framing again: most teams that fail at multi-agent haven't designed the workflow. They threw N agents at a task and hoped emergence would happen. Multi-agent is a discipline — clear specialization, clear hand-off rules, clear shared memory contract. Get those three right and it scales. Skip them and you've just multiplied your hallucination surface area.