Loading...
System Design and AI Engineering, by Roni Das. 980 interactive lessons.
Start LearningAI Engineering · Intermediate · LLM and GenAI Ops
An open-source framework for building AI agents as a graph of steps that share one state. Nodes do the work, edges pick the next step, and a checkpointer saves the state so a run can pause, resume and remember.
In short
LangGraph is free, open-source code from LangChain Inc for building AI agents (programs where an AI model decides the next step). You draw the agent as a graph: steps (nodes) joined by arrows (edges). The steps pass one shared record (the state) along. It saves that state after each step, so an agent can pause for a person, survive a crash and carry on, or remember a chat. You can use it without LangChain.
In short
LangGraph is free, open-source code from LangChain Inc for building AI agents (programs where an AI model decides the next step). You draw the agent as a graph: steps (nodes) joined by arrows (edges). The steps pass one shared record (the state) along. It saves that state after each step, so an agent can pause for a person, survive a crash and carry on, or remember a chat. You can use it without LangChain.
Learn it in the course
This page is the free part.
₹999 in India$49 everywhere elseonce, for the whole course
The AI Engineering course covers LangGraph across a run of lessons, not one page. These 4 alone are about 222 minutes of step-by-step reading, every one with code you run in the browser, all with a quiz.
A web request retries whole. An agent run cannot. Durable execution persists every step and recovers by replaying recorded results, not re-running non-deterministic model calls.
A language model does not write sentences. At every step it gives odds for every possible next token, and something else picks one. Measured with qwen2.5:3b on 24 prompts: for 12 facts the top next token had a median probability of 0.70; for 12 open prompts only 0.17. The same five words with and without the hidden chat template gave ' Paris' at 0.62 or 'The' at 0.999.
Teams abandon error analysis in a text editor and record it as a conclusion about the method. Three behaviours fix it, one feature ruins the measurement, and the whole thing is a hundred lines of Python.
pass@k and pass^k measure opposite things. See the math that makes a 95 percent per-step agent fail most 20-step tasks, with a Python example.
all part of
AI Engineering
210 lessons · about 219 hours · 10 free to read
₹999in India, by UPI
$49everywhere else, by PayPal
You own this course
Continue with Durable Execution: An Agent Run Is a Workflow, Not a Requestpay once,
yours for life
An AI agent is a program that uses a large language model (LLM), the kind of model behind ChatGPT, to decide what to do next. It calls tools, reads the results and decides again. A tool is just a function the agent may run, such as "look up an order".
Simple agents are a loop. Real ones need more control. Some steps must always happen in a fixed order. Some must wait for a person. And a long run must not lose its work if the server restarts.
LangGraph is a framework for that control. A framework is ready-made code you build on. The LangGraph docs call it "a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents." Orchestration means deciding which step runs when. Stateful means it remembers what happened so far. Low-level means you control the details yourself. A runtime is the part that actually runs your steps, and deploying means putting the program live on a server.
You describe your agent as a graph. In maths and programming, a graph is a set of points joined by lines. In LangGraph the points are steps and the lines say which step comes next. LangChain Inc builds it, but its docs say plainly: "you don't need to use LangChain to use LangGraph." It comes for Python and for JavaScript. The docs name Klarna, Uber and J.P. Morgan among the companies that use it.
You only need four ideas to read any LangGraph code.
One more word you will see is reducer. By default, when a node returns a field, the new value replaces the old one. A reducer changes that rule for one field. With operator.add on a list, new items are added to the end instead. That is how a chat history grows message by message.
The docs sum up the split well: "nodes do the work, edges tell what to do next."
Here is a tiny support router. It has no LLM in it, so it runs the same way every time. In a real agent, classify would ask a model. The shape of the code does not change.
Install it by running pip install -U langgraph in a terminal. pip is Python's tool for installing libraries. The code below ran on langgraph 1.2.16.
router.py
import operator
from typing import Annotated, TypedDict
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import END, START, StateGraph
class State(TypedDict):
question: str
kind: str
log: Annotated[list[str], operator.add] # reducer: new items are added, not replaced
def classify(state: State) -> dict:
kind = "refund" if "refund" in state["question"].lower() else "other"
return {"kind": kind, "log": ["classify"]}
def refund_desk(state: State) -> dict:
return {"log": ["refund_desk"]}
def faq_bot(state: State) -> dict:
return {"log": ["faq_bot"]}
def pick_next(state: State) -> str: # a conditional edge: code decides the next node
return "refund_desk" if state["kind"] == "refund" else "faq_bot"
builder = StateGraph(State)
builder.add_node("classify", classify)
builder.add_node("refund_desk", refund_desk)
builder.add_node("faq_bot", faq_bot)
builder.add_edge(START, "classify")
builder.add_conditional_edges("classify", pick_next, ["refund_desk", "faq_bot"])
builder.add_edge("refund_desk", END)
builder.add_edge("faq_bot", END)
graph = builder.compile(checkpointer=InMemorySaver())
config = {"configurable": {"thread_id": "chat-42"}}
out = graph.invoke({"question": "I want a refund", "log": []}, config)
print("kind:", out["kind"], "| log:", out["log"])
print("saved checkpoints for chat-42:", len(list(graph.get_state_history(config))))Output, captured 2026-10-18
kind: refund | log: ['classify', 'refund_desk']
saved checkpoints for chat-42: 4Read the output line by line. The question had the word refund, so pick_next sent the run to refund_desk. The log field has a reducer, so it holds both steps, classify then refund_desk, instead of only the last one.
The checkpointer saved 4 checkpoints for thread chat-42. One was saved when the input arrived and one as the graph started. Then one was saved after each of the two nodes. compile() turns your description into a graph that can run. You must call it before you run any graph. It checks that every node is connected, and it is where you attach the checkpointer.
InMemorySaver keeps checkpoints in the computer's working memory (RAM), so they vanish when the program stops. It is fine for tests. The docs say to "use a persistent checkpointer for production", such as PostgresSaver, which stores them in a PostgreSQL database. SqliteSaver is a file-based one for development.
Most teams pick LangGraph for one of four reasons. All four come from the same feature: the state is saved after each step.
LangGraph also gives you streaming (sending results while the run is still going), parallel nodes (nodes that run at the same time) and subgraphs (a graph used as one node in a bigger graph). Nodes that run at the same time share one super-step, an idea the docs say comes from Google's Pregel system for large graphs.
This is the question people ask most, so here is the short answer. LangChain is a library (a set of ready-made code) for LLM apps. It has model wrappers (code that calls different AI models in the same way), tools, prompts (the text instructions you send a model) and a ready-made agent you can start in a few lines. LangGraph is the lower layer that runs a graph of steps and saves its state.
The two are connected. In LangChain 1.x, the ready-made agent is itself built on LangGraph. Start with LangChain's agent when a simple tool loop is enough. Move to your own LangGraph graph when you need fixed steps, approvals, or runs that must survive a restart. The full comparison, with code for both, is on LangChain vs LangGraph.
Choose LangGraph when your agent has steps that must happen in order, needs a person to approve some actions, or runs long enough that a crash would hurt. It is also a good fit when you must show later exactly what the agent saw and did at each step.
It is a weaker fit for a single prompt, a simple chatbot, or a batch job (a big task run on a schedule, such as a nightly report) that a normal queue already handles. And a graph does not make a model more reliable by itself. Each LLM step can still fail. My agent loop lesson shows why errors pile up as the number of steps grows. My planning patterns lesson compares the two common shapes of an agent, ReAct (think, act, look, repeat) and plan-and-execute (write the whole plan first, then do it), both of which you can draw as a LangGraph graph.
For the interview side, see the AI agent system design guide and the customer support agent guide.
LangChain Inc
Builds LangGraph as open source, for Python and JavaScript. LangChain 1.x builds its ready-made agent on top of LangGraph.
Klarna, Uber and J.P. Morgan
Named in the LangGraph docs as companies that use it. The docs do not say for which products, so this page does not either.
PostgreSQL
The usual home for checkpoints in production, through PostgresSaver. One row set per checkpoint, filed under the thread id.
LangSmith
LangChain Inc's tracing and evaluation product. The LangGraph docs list debugging with LangSmith as one of its benefits; LangGraph itself does not need it.
LangGraph is an open-source framework for building AI agents as a graph of steps that share one state. Nodes do the work, edges choose the next node, and a checkpointer saves the state after each step. That lets an agent pause for a person, resume after a crash, and remember a conversation.
It is used for agents that need control: fixed steps mixed with model-driven steps, human approval before risky actions, long runs that must survive a restart, and chat memory across turns. Simple one-prompt apps do not need it.
State is the one shared record that every node reads. A node returns only the fields it wants to change. By default a new value replaces the old one; a reducer, such as operator.add on a list, can make it add to the old value instead.
A checkpointer saves the graph's state as checkpoints while a run moves, filed under a thread id. InMemorySaver keeps them in RAM for tests. For production the docs say to use a persistent one such as PostgresSaver.
It is made by the same company, LangChain Inc, and LangChain's own agent runs on it. But the LangGraph docs say you do not need LangChain to use LangGraph. You can write every node as plain Python.
The LangGraph library is open source and free to install with pip install -U langgraph. LangChain Inc also sells hosted products, such as LangSmith, which are separate.
AI Agent
A language model placed in a loop: it decides an action, calls a tool, reads the result, and repeats until done. The hard part is that per-step errors compound over many steps.
Human in the Loop (HITL)
An AI system stops at chosen points and waits for a person to approve, change or reject its next action before it happens. Used for actions that cost money or cannot be undone.
ReAct Agent
An AI agent that alternates reasoning and acting: it writes a thought, calls a tool, reads the result, and repeats until it can answer. ReAct is short for reason plus act.
Tool Calling
When a model emits a structured request to run a function, and an orchestrator executes it and feeds the result back. The model never runs anything itself, so the orchestrator validates every call.
Agentic Design Patterns
Reusable ways to structure an AI agent's work, such as ReAct, plan-and-execute, reflection and multi-agent setups. Each trades extra model calls for a chance at a better answer.
RAG (Retrieval-Augmented Generation)
A pattern that retrieves relevant text from an external index and puts it in the model's prompt so the answer is grounded in current, verifiable facts rather than the model's memory.
This page explains the idea. The "Durable Execution: An Agent Run Is a Workflow, Not a Request" lesson builds it up step by step, with diagrams. It is part of the AI Engineering course, which has 210 lessons. 10 of them are free to read. You pay once and keep it for life, with no subscription.
Open the Durable Execution: An Agent Run Is a Workflow, Not a Request lessoncourse 2
Take models from notebook to production, with labs on real models.
Asked about LangGraph in an interview?
Each question has why it is asked, a full answer, what the interviewer listens for, the follow-ups, the common mistakes and a diagram (153 diagrams in all). A PDF you keep, junior to staff level.
India: UPI, cards or netbanking through Razorpay. Elsewhere: card or PayPal. Download at once from My packs.
