Pick one of AutoGen, CrewAI, a LangGraph supervisor graph, and the OpenAI Agents SDK for a deep research multi-agent product and defend the choice.

Short answer·Hard·4.0 · 0·~3 min·Asked atArize Ai Gnani Lambda Labs

Attempt it

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 an AutoGen group chat team, CrewAI, a LangGraph supervisor graph, or the OpenAI 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. One node decomposes the query, several worker nodes retrieve and analyse in parallel, and one node synthesizes the final report. That is the supervisor pattern with conditional routing. A supervisor node picks the next worker. Workers report back to the supervisor. The supervisor decides whether to dispatch another worker or hand off to the synthesizer. The checkpointer persists state between every step. The others fit this shape less well. **AutoGen GroupChat** is built for exploratory chats where any agent can speak next, so structured fan-out is awkward. AutoGen is also archived. **CrewAI** is built for sequential or hierarchical task pipelines where roles drive the flow. Its observability and conditional routing are weaker than LangGraph's. **OpenAI Swarm** is an educational reference, and the **Agents SDK** that replaced it is intentionally minimal: handoffs are tool calls and there is no explicit graph. That is great for two-agent handoffs, but you build the fan-out coordination and run-level persistence yourself. 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 → synthesizer) maps directly to the supervisor pattern with conditional routing. Build it as your own StateGraph. The docs recommend the pattern directly rather than the `langgraph-supervisor` library. 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, and AutoGen is archived. Agents SDK handoffs pass control to one 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 snapshots every super-step and makes runs resumable. CrewAI checkpoints after each Task by default, and Agents SDK sessions store conversation memory rather than graph state. **Requirement 3. Inspectability and human in the loop.** Research products benefit from approval gates between planning and execution. LangGraph's `interrupt()` with `Command(resume=...)`, plus `update_state` for edits, is first-class. CrewAI offers per-Task `human_input`, and the Agents SDK pauses only to approve tool calls (`needs_approval`). **When the pick changes.** If the workload were a free-form analyst chat (a group-chat pattern), a strict sequential pipeline (CrewAI), or a two-agent triage (Agents SDK handoffs), the pick would change. The shape selects the framework, not the brand.

TL;DR

LangGraph supervisor. The deep-research shape is a supervisor with conditional routing graph, and among the four only LangGraph offers explicit routing, durable state via the checkpointer, and inspectability together.

Memory aid

Easy to grasp

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. The OpenAI Agents SDK is two friends passing a question back and forth via short notes. LangGraph is a project manager with a wall-sized chart, a planner that saves after every step, and an interruptible workflow. For a planner, workers and synthesizer 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.

Key concepts

LLM Frameworks Multi-Agent Systems

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Multi-agent orchestration choice is one of the few framework decisions where the workload shape narrows the field. A deep-research product (planner decomposes, workers fan out and analyse, synthesizer composes) has three structural requirements that select one framework family over the others.

'Depends on your team' skips the analysis. Mapping the shape to the requirements shows which framework satisfies them. The four candidates (AutoGen, CrewAI, LangGraph supervisor and the OpenAI Agents SDK) each fit a typical shape, and only one of those shapes matches this product.

The shape and its requirements

The planner, fan-out, synthesizer shape is the textbook supervisor pattern. The supervisor dispatches one of several workers. Workers operate in parallel and report back. The supervisor decides whether to dispatch more workers or hand off to the synthesizer. The synthesizer composes the final report.

This shape has three structural requirements.

Explicit routing. The supervisor must pick the next worker (or fan out to many) based on the planner's decomposition. The routing must be inspectable, deterministic, and replay-safe.
Durable state. Research runs are long. Partial worker outputs must survive a crash, and a human must be able to inspect a run mid-flow without aborting it.
Inspectability and human gates. Research products benefit from approving the plan before workers execute, and from time-travel debugging when a synthesized answer is wrong.

Each requirement maps to a framework primitive. Frameworks that lack the primitive force you to build it yourself. That build cost is what selects the right framework.

Why LangGraph supervisor satisfies all three

Why AutoGen loses for this workload

Why CrewAI and the Agents SDK lose for this workload

Production posture

Situations where this technique stops working.

2–4 min · Everything important, quickly.

python

import operator
from typing import Annotated, TypedDict

from langgraph.graph import StateGraph, END
from langgraph.types import Send
from langgraph.checkpoint.postgres import PostgresSaver

class State(TypedDict, total=False):
    query: str
    subqueries: list[str]
    subquery: str
    findings: Annotated[list, operator.add]  # reducer merges parallel worker writes
    report: str

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(State)
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)

with PostgresSaver.from_conn_string(POSTGRES_URL) as checkpointer:
    checkpointer.setup()  # create checkpoint tables once
    app = g.compile(checkpointer=checkpointer)

Framework	Routing shape	Persistence	Best fit
LangGraph supervisor	Conditional edges + Send	Postgres checkpointer, time-travel	Planner, fan-out, synthesizer
AutoGen group chat team	Speaker selection (chat-shaped)	Team save_state / load_state; repo archived	Free-form analyst chat
CrewAI	Role/goal text, Hierarchical Process	Task-level checkpointing (checkpoint=)	Sequential or hierarchical role pipelines
OpenAI Agents SDK	Handoff via tool call; agents as tools	Sessions for conversation memory; no graph checkpointer	Two-agent triage and handoff

Real products, models, and research that use this idea.

Anthropic's multi-agent research system (June 2025) uses a lead agent that plans, spawns parallel subagents, and compiles their findings: the planner, workers and synthesizer shape
LangChain's open_deep_research project builds a supervisor that delegates to parallel researcher subgraphs on LangGraph, then writes a final report

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?

Walk through how Send dispatches parallel node invocations with their own input state, how the super-step checkpoint keeps pending writes from finished branches so they are not re-run on resume, and how a reducer joins their results back into the parent state.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases 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.

60 second bullets to scan on the way to the call.

Why the planner, fan-out, synthesizer shape maps to supervisor with conditional routing
Three structural requirements: routing, durability, inspectability

Primary sources. Browse if you want the original framing.