`create_react_agent` is LangGraph's prebuilt for the most common agent shape: a single LLM that can call tools, gets the tool result back, decides whether to call another tool or finish, and emits the final message. It assembles the StateGraph for you, ships a default state schema with a messages list, and wires in a checkpointer so the agent can be paused and resumed.
It wins when your case matches that shape. A tool-using assistant, a code agent with shell access, a Q&A bot that can look things up. All of these are vanilla ReAct loops and the prebuilt saves you 30-50 lines of graph construction.
It loses when you want anything custom. Need extra state fields beyond messages (a counter, a scratchpad, structured plan)? Need to branch to different sub-agents based on what the tool returned? Need a human-approval interrupt at one specific point and not others? Those cases mean writing the StateGraph by hand. Not because the prebuilt is bad, but because the prebuilt's preset does not match what you need.
The other three options are false on the facts. The prebuilt is not deprecated, it is model-agnostic, and StateGraphs stream perfectly well.
**The right answer is the second option.** `create_react_agent` is the prebuilt for the standard tool-calling ReAct loop. LLM, optional tool call, LLM with the tool result, repeat until no tool call, return. It comes with a baked-in state (messages list plus tool-call tracking), accepts a checkpointer for persistence, and saves you the 30-50 lines you would write defining a StateGraph by hand for the same shape.
**When to reach for a hand-written StateGraph instead:**
- **Custom routing.** You want to branch to different sub-agents based on what a tool returned. The prebuilt has one model node and one tools node; a hand-written graph has as many nodes and conditional edges as you need.
- **Extra state fields.** The prebuilt's state is messages-shaped. If you need a typed plan, a counter, a scratchpad, or structured intermediate results that are not just messages, you need your own TypedDict state.
- **Parallel branches.** Fan-out to several tools or sub-agents in parallel and merge. LangGraph's super-step model supports it, the prebuilt does not expose it.
- **HITL at specific points.** Interrupt before tool execution? Before final synthesis? After a particular routing decision? Hand-rolled graphs let you place interrupts anywhere; the prebuilt offers one coarse interrupt point.
The other three options are wrong on the facts. The prebuilt is actively recommended, not deprecated. It is model-agnostic. StateGraphs support streaming via `.stream` and `.astream` with several modes.
Quick reference
TL;DR
create_react_agent wins on the standard tool-calling loop with a baked-in messages state; reach for a hand-written StateGraph when routing, state, or interrupts get custom.
Imagine ordering coffee. The default menu has espresso, latte, and cappuccino. Three preset orders the barista makes in seconds. If that is what you want, you say 'latte' and you are done.
If you want oat milk, half the foam, an extra shot, and a sprinkle of cinnamon on top, you have to spell out each step. The preset menu does not have a button for it.
LangGraph's create_react_agent is the preset menu. A standard tool-calling loop with one well-known shape. The hand-written StateGraph is the custom order. More typing, but you can spell out every step the way you want.
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.
Supervisor + worker multi-agent topology The prebuilt has one model node; supervisor patterns need explicit routing to different worker nodes. Write the StateGraph.
Agent needs a typed plan, counter, or structured scratchpad in state create_react_agent's state is messages-shaped; extending it requires a custom StateGraph with your own TypedDict.
HITL flow that approves only specific tool calls, not all of them Prebuilt interrupt is coarse (before all tools); per-tool approval requires placing interrupts on specific edges in a hand-rolled graph.
Parallel fan-out where multiple branches need to merge with a reducer The prebuilt's loop is sequential; super-step parallelism is a StateGraph feature.
Quick scan · 2–4 min
Everything important, quickly.
5 min: the ReAct loop the prebuilt encodes, what state it locks you into, why customisation forces StateGraph, and how checkpoints carry over on migration.
Side-by-side
Axis
create_react_agent
Hand-written StateGraph
State schema
Messages-only (fixed)
Any TypedDict you define
Topology
model → tools → model
Any nodes and edges you need
Custom routing
No
Conditional edges, per-output dispatch
Interrupts
interrupt_before_tools toggle
interrupt_before / after any node
Parallel branches
No
Yes (super-step + reducers)
Best for
Tool-using agent with no custom flow
Multi-agent, plans, structured state, HITL
Real-world examples
Real products, models, and research that use this idea.
1LangChain's own agent templates default to create_react_agent for tool-using bots, swapping to StateGraph for the supervisor and swarm templates.
2LangGraph Studio shows create_react_agent runs as a fixed two-node graph; custom StateGraphs render with whatever topology the developer drew.
3Replit's coding agent and Cursor's chat use custom StateGraphs because the routing branches across multiple sub-agents and tool surfaces.
4OpenAI Swarm and Anthropic's tool-use guide describe the same vanilla ReAct loop that create_react_agent encapsulates. Different framework, same preset.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow would you migrate from create_react_agent to a hand-written StateGraph without losing checkpoint compatibility?
Sign in or go Pro to see the approach for this follow-up.
QWhat does the prebuilt's interrupt_before_tools actually let you do?
Sign in or go Pro to see the approach for this follow-up.
QCould you implement create_react_agent yourself in 30 lines?
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
Calling create_react_agent deprecated and writing a StateGraph for a vanilla tool-calling loop. 40 lines of boilerplate the prebuilt would have given you for free.