You are building a deep-research multi-agent product where a planner agent decomposes a query, several worker agents fan out to retrieve and analyse, and a synthesizer composes the final report. Pick one of AutoGen GroupChat, CrewAI, LangGraph supervisor, or OpenAI Swarm / Agents SDK as the orchestration layer, and defend the choice against the other three.
Free · 2 AI evals / day
**LangGraph supervisor** is the best fit for a deep-research product with a planner, fan-out workers, and a synthesiser.
The shape. One node decomposes the query, several worker nodes retrieve and analyse in parallel, one node synthesises the final report. Is exactly the supervisor pattern with conditional routing. A supervisor node picks the next worker via a routing function; workers report back to the supervisor; the supervisor decides whether to dispatch another worker or hand off to the synthesiser; and the checkpointer persists state between every step.
Why not the others. **AutoGen GroupChat** is built for exploratory chats where any agent can speak next; the structured fan-out you have is awkward to express. **CrewAI** is built for sequential or hierarchical task pipelines where roles drive the flow; observability and conditional routing are weaker than LangGraph's. **OpenAI Swarm / Agents SDK** is intentionally minimal, handoffs are tool calls, no explicit graph, which is great for two-agent handoffs but leaves you reinventing supervisor logic and persistence for a multi-worker fan-out.
The deciding criteria are explicit control of routing, durable state via the checkpointer, and inspectability of the loop. LangGraph wins on all three.
**LangGraph supervisor** is the best fit. The workload, planner → fan-out workers → synthesiser, maps directly to the supervisor pattern with conditional routing, and three structural requirements select LangGraph over the alternatives.
**Requirement 1. Explicit routing.** The supervisor needs to dispatch one of several workers based on the planner's decomposition. LangGraph's conditional edges plus Send (parallel fan-out) express this cleanly. CrewAI's hierarchical Process can express delegation but the routing is implicit in role/goal text. AutoGen's speaker selection is chat-shaped, not fan out shaped. Swarm's tool-call handoffs are two-agent, not one to many.
**Requirement 2. State durability.** A deep-research run is long; partial worker outputs must survive a crash and a human must be able to inspect mid-run. LangGraph's Postgres checkpointer makes Tasks first-class and resumable. The others either lack durable state or treat it as an add-on.
**Requirement 3. Inspectability and human in the loop.** Research products benefit from approval gates between planning and execution. LangGraph's `interrupt_before` and `update_state` are first-class. CrewAI has callbacks but no checkpointer; AutoGen has no native interrupt; Swarm is too thin to offer either.
**Honest caveat.** If the workload were a free-form analyst chat (AutoGen), a strict sequential pipeline (CrewAI), or a two-agent triage (Swarm), the pick would change. The shape selects the framework, not the brand.
Quick reference
TL;DR
LangGraph supervisor. The deep-research shape is a supervisor with conditional routing graph, and only LangGraph offers explicit routing, durable state via the checkpointer, and inspectability together.
Picture coordinating a small research team. AutoGen is a free-form brainstorm in a chat room. Anyone can speak. CrewAI is a relay race where each runner hands the baton to the next in order. Swarm is two friends passing a question back and forth via short notes. LangGraph is a project manager with a wall-sized chart, a save every step planner, and an interruptible workflow. For a planner workers synthesiser product where you need to know who is running, save partial progress, and let a human approve the next step, the project manager wins. The other three are good at different shapes.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Free-form analyst chat where any agent can respond at any turn AutoGen GroupChat's speaker-selection is purpose-built for that shape; LangGraph's explicit routing is overkill.
Strict sequential pipeline driven by roles (research → draft → review) CrewAI sequential Process is shorter and clearer; LangGraph adds graph machinery you do not need.
Two-agent triage with one handoff (front-line → specialist) OpenAI Swarm / Agents SDK is intentionally minimal for this shape; LangGraph's supervisor adds boilerplate.
TypeScript-only stack with no Python service available LangGraph Python is the mature implementation; in TS, Mastra or a hand-rolled state machine often beats LangGraph.js.
Quick scan · 2–4 min
Everything important, quickly.
8 min: shape selection, three structural requirements, specific weaknesses of each alternative, Send for parallel fan-out, production posture with retrieval pairing.
Code example
python
from langgraph.graph import StateGraph, END
from langgraph.constants import Send
from langgraph.checkpoint.postgres import PostgresSaver
def plan(state):
return {"subqueries": planner_llm(state["query"])}
def dispatch(state):
# Parallel fan-out: one Send per subquery, each runs the worker node
return [Send("worker", {"subquery": sq}) for sq in state["subqueries"]]
def worker(state):
return {"findings": [analyse(retrieve(state["subquery"]))]}
def synthesise(state):
return {"report": synth_llm(state["findings"])}
g = StateGraph(dict)
g.add_node("plan", plan)
g.add_node("worker", worker)
g.add_node("synth", synthesise)
g.set_entry_point("plan")
g.add_conditional_edges("plan", dispatch, ["worker"])
g.add_edge("worker", "synth")
g.add_edge("synth", END)
app = g.compile(checkpointer=PostgresSaver.from_conn_string(POSTGRES_URL))
Side-by-side
Framework
Routing shape
Persistence
Best fit
LangGraph supervisor
Conditional edges + Send
Postgres checkpointer, time-travel
Planner fanout synthesizer
AutoGen GroupChat
Speaker selection (chat-shaped)
Shallow in 0.4
Free-form analyst chat
CrewAI
Role/goal text, Hierarchical Process
Callbacks, no checkpointer
Sequential or hierarchical role pipelines
OpenAI Swarm / Agents SDK
Handoff via tool call
None native
Two-agent triage and handoff
Real-world examples
Real products, models, and research that use this idea.
1Anthropic's Claude research preview uses a planner workers synthesizer pattern that maps to a LangGraph-style supervisor
2OpenAI's Deep Research product implements a similar shape under the hood, planner, parallel browsers, synthesiser, backed by durable state for long-running queries
3Perplexity's pro-search and follow-up flows use multi-agent decomposition that benefits from supervisor routing and persistence
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow does LangGraph's Send primitive interact with the checkpointer for parallel fan-out?
Sign in or go Pro to see the approach for this follow-up.
QWhen would you migrate a CrewAI hierarchical Process to LangGraph supervisor?
Sign in or go Pro to see the approach for this follow-up.
QHow would you add human in the loop approval between planning and worker dispatch?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Defaulting to the 'depends on your team' non-answer. The deep-research shape has structural requirements (routing, persistence, inspectability) that select for LangGraph regardless of team taste.