Pick the LangGraph prebuilt that fits a workflow with no central router

MCQ·Medium·4.0 · 0·~1 min·Asked atAlibaba Hugging Face Kpmg

Attempt it

**The correct answer is create_swarm.** LangGraph ships two main multi-agent prebuilts: - **create_supervisor**: a central manager agent reads each turn, picks a worker, and routes to it. One supervisor LLM call per hop, plus the worker call. - **create_swarm**: agents are peers. Each agent has handoff tools (`transfer_to_search_agent`, `transfer_to_review_agent`). When an agent decides it should hand off, it calls the handoff tool, and the runtime swaps the active agent. No central manager call per hop. The question asks for a workflow with no central router. Swarm matches. **Why the other options are wrong:** - create_supervisor is the opposite topology (centralised routing). - StateGraph with a single self-looping node is just one agent; there are no workers to hand off to. - ToolNode is a helper for executing tool calls, not a topology. **When to use each.** Swarm wins on cost (no per-hop supervisor call) and works well when the routing decision is local (the current agent knows when it is done and who should be next). Supervisor wins when the routing decision is hard and needs reasoning over the full conversation, or when you want a central place to enforce policy.

**The answer is create_swarm.** It is the LangGraph prebuilt explicitly designed for peer-handoff topologies. Agents are wired with handoff tools (`transfer_to_X`), and when an agent calls a handoff tool the runtime swaps the active agent and continues with the same shared state. No central manager LLM call per hop; the routing decision lives inside the worker itself. **The trade-off versus create_supervisor:** - **Cost**: swarm wins. Saves one LLM call per hop (the supervisor's call). On a 6-hop run, that is 6 fewer routing calls. - **Latency**: swarm wins for the same reason; one fewer serial LLM call per hop. - **Routing quality**: supervisor wins when the routing decision is hard. The supervisor sees the full conversation and can route based on global context; the swarm worker only has its own context to decide when to hand off. - **Policy enforcement**: supervisor wins. There is a single chokepoint where guardrails and routing constraints apply; in swarm, every agent has to implement the same constraints. **Why the wrong options are wrong:** - **create_supervisor** is the opposite topology (centralised routing); the question explicitly rules it out. - **StateGraph with one self-looping node** is a single agent, not multi-agent. - **ToolNode** wrapped around every agent is a tool-execution helper, not a topology primitive. The useful intuition: name maps to topology. 'Swarm' literally means peer to peer; 'supervisor' literally means central authority. When the question rules out a central authority, swarm is the only match.

TL;DR

create_swarm is the LangGraph prebuilt for peer-handoff topologies; agents transfer control directly via handoff tools and the runtime swaps the active agent without a central manager call per hop.

Memory aid

Easy to grasp

Imagine a relay race versus a meeting room. In the relay (swarm), each runner directly hands the baton to the next runner; no coach in the middle. In the meeting room (supervisor), every runner reports to the coach and the coach decides who runs next. Swarm is faster and cheaper when runners can decide handoffs themselves; supervisor is needed when the routing decision is hard and needs a manager. LangGraph ships create_swarm for the relay model and create_supervisor for the meeting-room model. The question is which one matches your workflow.

Key concepts

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.

LangGraph ships two main multi-agent topologies as prebuilts: create_supervisor and create_swarm. They embody opposite design philosophies. Supervisor is centralized: every hop, a single manager agent decides which worker runs next. Swarm is decentralized: agents are peers and hand off directly to each other via tool calls.

Picking the right one is not a stylistic choice; it is a cost, latency, and architecture decision. The question prompts a workflow with no central router, which rules supervisor out by definition. This walkthrough explains why swarm fits, what the trade-offs are versus supervisor, and how to think about the hybrid case where you actually need both.

Mental model: swarm is peer to peer with handoff tools; supervisor is centralized with a manager per hop. Name maps to topology; pick by who decides routing.

What create_swarm is

The primitive

create_swarm is a LangGraph helper that takes a list of agents (each defined as a create_react_agent or similar) and wires them together with handoff tools. A handoff tool has the shape:

python

def transfer_to_review_agent():
    return Command(goto='review_agent')

When the currently active agent calls this tool, the runtime updates the active_agent field in shared state and routes the next graph step to the named agent. The shared state (messages, scratch, accumulated context) carries forward unchanged.

What the runtime is doing

One agent is 'active' at any moment.
On each step, the active agent runs an LLM call.
If the LLM output includes a tool call to a handoff tool, the runtime processes the handoff (updates state, swaps active agent).
If the LLM output is a regular tool call, the tool runs and the same agent continues.
If the LLM output is a final answer, the run terminates.

No supervisor call per hop

In create_supervisor, every hop includes one supervisor LLM call (routing decision) plus one worker LLM call (work). In create_swarm, only the active agent's LLM call runs each hop; there is no separate supervisor turn. That is the cost savings.

Swarm versus supervisor: the trade-off in numbers

When to pick which

Distractor analysis

Situations where this technique stops working.

2–4 min · Everything important, quickly.

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

OpenAI's Swarm framework popularised the peer-handoff pattern; LangGraph's create_swarm is the production-grade equivalent.
OpenAI Agents SDK uses the same handoff-tool primitive for peer transfers, and there are migration guides from Swarm to Agents SDK.

What an interviewer would ask next. Try answering before peeking at the approach.

QHow would you implement allowed-target lists on handoff tools in a swarm?

Each agent registers only the handoff tools it is allowed to call; the agent definition imports only the relevant transfer functions. Alternatively, register all handoff tools but wrap each in a per-agent permission check that fails the call when the source agent is not in the allowed-source list. The first is cleaner; the second is more dynamic.

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

Reaching for create_supervisor by default because it sounds more structured, then paying a per-hop supervisor LLM call for routing decisions the workers could have made via handoff tools.

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

What create_swarm is in LangGraph
What create_supervisor is and how it differs

Primary sources. Browse if you want the original framing.