Explain the structural difference between a LangGraph StateGraph and a standard DAG-based LLM pipeline. What specific graph feature enables the agent's 'retry until done' pattern?
Free · 2 AI evals / day
A **DAG** is a directed acyclic graph. Acyclic means it has no cycles, so every edge points forward and you can never return to a node you already ran. Classic LLM pipelines, like a chain that retrieves then generates then formats, are DAGs. They run each step exactly once in a fixed order.
That shape cannot express an agent. An agent does not know up front how many steps it needs. It reasons, calls a tool, looks at the result, and often has to reason again with that new information. That means going back to an earlier step, which a DAG forbids.
LangGraph's **StateGraph** removes the acyclic restriction. It is a directed graph that allows cycles, so an edge can point from a later node back to an earlier one. After the tool node runs, an edge can route back to the reasoning node to try again.
The piece that decides is a conditional edge. It reads the shared state and picks the next node: loop back if the agent is not done, or go to the end if it is. Because the loop lives in the graph, you can draw it, pause it, save a checkpoint, and replay it, instead of hiding it in a plain while loop.
A **DAG** pipeline allows edges in one direction only. Nodes run in topological order, each exactly once, with no path back to an earlier node. That fits a fixed workflow like retrieve then generate. It cannot express an agent that must revisit its reasoning step after every tool call.
LangGraph's StateGraph drops the acyclic constraint. It is a directed graph that permits cycles, so an edge can point from a later node back to an earlier one. The agent loop becomes a first-class topology: a reason node, a tool node, and a loop-back edge between them.
The deciding mechanism is the conditional edge. After a node runs, a routing function reads the shared state and returns the name of the next node. It sends control back to the reason node while work remains, or forward to the end node once the model signals completion.
The loop is state-driven, not a fixed counter. The condition tests an actual value in state, such as whether a final answer was produced. Because the cycle is an explicit graph object, it is inspectable, checkpointable at each node, and resumable, unlike a while loop buried in application code.
Quick reference
TL;DR
A DAG forbids cycles, so it cannot loop back; StateGraph allows directed cycles, and a conditional edge routes on state to repeat the reason step or terminate.
Think of a board game with a track of squares. A normal pipeline is a track where you only move forward, one square at a time, until you reach the end. You can never go back. That is fine for a recipe you follow once, but an agent does not know in advance how many tries it needs. LangGraph lets you draw an arrow from a later square back to an earlier one, so the player can loop around again. At the end of each loop there is a decision square. Look at the current situation, and if the job is done, walk off the board, otherwise take the arrow back and try again. The decision is written on the board itself, not hidden in someone's head, so anyone watching can see the whole game and where the player keeps getting stuck.
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.
The workflow is fixed and linear, such as retrieve then generate then format, with no runtime branching. A plain LCEL chain or DAG gives bounded latency and far less boilerplate than a typed graph.
A quick prototype where a prebuilt ReAct agent already covers the observe reason act loop. Hand-authoring schema, nodes, edges, and reducers is wasted effort when the prebuilt loop suffices.
Tight latency budgets where every node transition and checkpoint write adds overhead. Persistence and graph dispatch cost time that a simple in-memory loop avoids.
A team unfamiliar with state machines maintaining a small, rarely changing agent. The added rigidity raises the learning curve without paying back in durability or branching.
Quick scan · 2–4 min
Everything important, quickly.
Start from the acyclic definition and why topological order cannot loop, then introduce StateGraph cycles, the conditional edge as the state-driven router, typed state with reducers, and checkpointing for resume and human in the loop. Close on when the explicit graph beats an implicit ReAct loop and the rigidity cost you pay.
Real-world examples
Real products, models, and research that use this idea.
1LangGraph's create_react_agent compiles a reason node and a tool node joined by a conditional edge, producing the canonical observe reason act loop as an inspectable state machine.
2LangGraph checkpointers like MemorySaver, SqliteSaver, and Postgres snapshot state after each node, powering pause and resume and human approval flows in agents built on Claude Opus 4.7 or GPT-5.5.
3Klarna and Replit have described LangGraph-style state machines for support and coding agents where durable resume across failures matters more than minimal latency.
4LangGraph Studio renders the compiled StateGraph as a node and edge diagram and lets engineers step through each checkpointed cycle to debug a stuck loop.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow does a reducer change the semantics of a state update when two nodes write the same key concurrently?
Sign in or go Pro to see the approach for this follow-up.
QHow would you add a human approval step before a tool call inside a StateGraph loop?
Sign in or go Pro to see the approach for this follow-up.
QWhen does the rigidity of an explicit StateGraph stop being worth it versus an implicit ReAct loop?
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
Saying StateGraph is just a nicer wrapper around a while loop. The real difference is that the loop becomes a typed graph object you can inspect, checkpoint, resume, and interrupt.