Architecture
A supervisor-worker multi-agent architecture where an orchestrator agent receives a high-level goal, breaks it into subtasks, delegates each to specialist worker agents (researcher, writer, QA), monitors execution, handles failures, and synthesizes results. The orchestrator manages but does not execute tasks itself.
orchestrator_agent {# Orchestrator Agent
n1: rectangle label="Decompose & Manage Subtasks"
n5: diamond label="All Passed QA?"
n6: rectangle label="Synthesize Final Result"
n1.handle(bottom) -> researcher_agent.n2.handle(top) [label="Task: Gather Sources"]
n1.handle(bottom) -> writer_agent.n3.handle(top) [label="Task: Draft"]
n1.handle(bottom) -> qa_agent.n4.handle(top) [label="Task: Review"]
n5.handle(right) -> n6.handle(left) [label="Yes"]
n5.handle(top) -> writer_agent.n3.handle(top) [label="No (Fix Draft)"]
}
researcher_agent {# Research Agent
n2: rectangle label="Retrieve Information (Web/RAG)"
n2.handle(right) -> orchestrator_agent.n1.handle(right) [label="Summary"]
}
writer_agent {# Writer Agent
n3: rectangle label="Generate Text"
n3.handle(right) -> orchestrator_agent.n1.handle(right) [label="Draft"]
}
qa_agent {# QA Agent
n4: rectangle label="Review Output"
n4.handle(right) -> orchestrator_agent.n5.handle(left) [label="Flags"]
}
loop [retry loop] writer_agent.n3 qa_agent.n4 orchestrator_agent.n5
Architecture
A sequential pipeline multi-agent architecture where agents are arranged in a strict sequence. Each agent transforms or enriches the output of the previous one, then passes it forward. No central orchestrator — the flow is deterministic like an assembly line.
Architecture
A swarm multi-agent architecture where multiple agents work on the same or related tasks simultaneously, with no central coordinator. Their outputs are then aggregated, voted on, or merged by a dedicated aggregator node. Agents may compete — the best output wins.
Architecture
A hierarchical multi-agent architecture with multi-level organizational structure. A top-level executive agent manages mid-level team lead agents, who each manage their own pool of specialist workers. Teams within teams — the hierarchy maps to domain separation.
Architecture
The most architecturally sophisticated multi-agent pattern. Agents are assigned not just roles but opposing incentives. A Planner is optimistic about goal completion. A Critic is constitutionally skeptical and holds veto authority. Errors get caught through adversarial pressure rather than trusting a single model's self-assessment.
Architecture
Multi-agent coordination pattern where an orchestrator breaks work into subtasks, specialist agents pull from and push to a shared state store, and the orchestrator composes the final answer from that shared state. Multi-agent setups feel coherent instead of each assistant having its own inconsistent memory.
Architecture
An orchestrator-worker architecture where an orchestrator agent breaks a goal into subtasks, dispatches to specialized workers, then synthesizes a final response. This is the most common 'agent orchestration' architecture—powerful but the orchestrator can become a bottleneck as the number of workers grows. Frameworks like LangGraph focus on explicit routing/state to manage this.