STATEFUL AI WORKFLOWS
LangGraph
Build stateful, controllable agent workflows with explicit graphs, durable execution, memory, streaming and human oversight.
LangGraph Learning Path
Follow the modules in order to learn LangGraph's mental model, graph primitives, routing, agents, memory, human-in-the-loop patterns, observability and production architecture.
Why LangGraph Exists
See exactly where LangChain's own agent abstractions start to strain under real workflow complexity, and why an explicit, stateful graph becomes the honest answer — grounded in Klarna's real, documented outcome.
The LangGraph Mental Model: State, Nodes, Edges, Routing
Build the complete mental map this entire course runs on — one clear layer at a time — and see exactly what graph.invoke() is actually doing underneath, so it never feels like magic.
State in LangGraph: How Agent Workflows Store and Update Data
The foundational module — build real state schemas from a single field up to nested, multi-part workflow data, and see exactly what a node changes and leaves untouched, before and after, every single time.
Nodes: The Real Units of Work in a Graph
A node is not synonymous with an LLM call. See seven genuinely different kinds of real work — pure Python, models, tools, retrieval, business APIs, human decisions, and even a whole agent — each as a node.
Edges: Connecting Nodes Into a Workflow
Nodes do the work; edges decide what happens next. Build real sequential chains, understand fan-in, and get a clear roadmap of the three tiers of routing this course covers.
START and END: Why Explicit Entry and Exit Points Matter
Every graph needs a genuine, unambiguous place to start and real ways to actually finish. See multiple termination routes, conditional entry, and what really happens when a graph accidentally has no way out.
Building Your First Complete Graph
Assemble everything from state, nodes, edges, START, and END into one real, growing graph — starting genuinely small, then extending it, then properly inspecting what actually comes out.
Conditional Edges: Letting State Drive the Path
Five genuinely real routing scenarios — model selection, support routing, RAG-vs-direct, tool selection, human escalation — plus a clear answer to where routing logic actually belongs.
Command: Updating State and Routing in One Step
For the genuinely common case where a node needs to both update state AND decide where to go, Command combines the two — see it built directly, and compared honestly against conditional edges.
Send: Dynamic Parallelism for an Unknown Number of Branches
Static parallel branches only work when you already know how many you need. See exactly where that assumption breaks, and how Send fans out to a genuinely unknown number of branches, decided at runtime.
Reducers: How Parallel Writes to the Same State Field Combine
Resolve the exact bug Module 10 left open — watch two parallel branches silently collide on one field, then fix it properly with reducers, built from a concrete problem outward, not from theory inward.
Messages and MessagesState: Connecting LangChain Messages to Graph State
Apply Module 11's reducer mechanism to the single most common real accumulation need — a growing conversation — and meet MessagesState, the prebuilt class that already wires it in for you.
Loops: Generate, Review, Revise
Build a genuine, working revision loop from scratch, watch its state evolve across real iterations, and add the bounded retry count every real loop needs — grounded in AutoGPT's real, documented runaway-cost failure.
Tool-Calling Workflows in LangGraph
Build the exact ReAct-style tool loop from raw graph primitives first, then meet ToolNode and tools_condition — the real, current prebuilt shortcuts for the same thing — plus genuine tool error handling.
Building Agents with LangGraph's Prebuilt Tools
Meet create_react_agent, LangGraph's own native agent constructor, and get a precise, honest answer to a question you've probably been wondering since Module 1: how does this relate to LangChain's create_agent?
Checkpointing: Making Graph Execution Recoverable
Module 1 opened with a question this course never actually answered: how does a workflow genuinely pause, persist, and recover? This module gives the real, complete answer.
Threads: Giving Each Conversation Its Own State
The real thread_id mechanism from Module 16, properly explained — how it keeps many real, concurrent conversations genuinely isolated, and the real, serious mistake that happens when it isn't.
Memory in LangGraph: Checkpoint, Thread, and the Long-Term Store
A precise, honest comparison of six terms that get blurred together constantly, plus the real mechanism for memory that genuinely survives across separate threads, not just within one.
Interrupts: Pausing a Graph for Human Approval
Module 1's refund-approval scenario, finally, properly resolved. Genuinely pause execution mid-run, persist exactly where you stopped, and resume — not a simulation, the real mechanism.
Human-in-the-Loop: Approve, Reject, Modify, Resume
Real applications need more than a yes/no interrupt. Build all four genuine patterns — approval, rejection, modification, and escalation on timeout — on top of Module 19's real mechanism.
Durable Execution: When Agents Run for Hours, Not Seconds
Checkpointing and interrupts already gave you real persistence and pausing. This module covers what changes when a workflow needs to survive not just a crash, but hours or days of real, elapsed time — and one honest gap worth knowing about.
Subgraphs: Composing Large Workflows From Smaller Ones
Watch a real graph grow into something genuinely hard to read, then break it apart into modular, independently testable subgraphs — with a precise look at how parent and child state actually interact.
Multi-Agent Systems: Supervisor, Handoff, and Agents-as-Tools
You already know these architectures conceptually. This module is purely implementation — building Supervisor, Handoff, and Agents-as-Tools directly in LangGraph, starting small and growing one real piece at a time.
Parallel Execution: Fan-Out, Fan-In, and Real Trade-offs
Revisit Module 10's Send mechanism at real production depth — what genuinely happens when one of many parallel branches fails, when a provider rate-limits you mid-fan-out, and what parallelism actually costs.
Error Handling, Retries, and Fallbacks in a Graph
Six genuinely realistic failure modes — node exceptions, tool failures, timeouts, invalid structured output, retriever errors, and human rejection — each handled as real graph structure, not just a wrapped function call.
Streaming, Observability, and Debugging a Running Graph
Every failure mode from the last module raises the same real question: which node ran, what state went in, what came out, why this edge? This module answers it — five stream modes, astream_events, and real debugging discipline.
Testing Nodes, Routers, Reducers, and Whole Graphs
A real, layered test suite for everything this course has built — nodes, routers, reducers, loop termination, interrupts, recovery, subgraphs, and entire graphs — using pytest, exactly like your LangChain course's own testing discipline.
Production LangGraph Architecture
Every production-relevant lesson from this entire course, gathered into one real, complete architecture — persistence, scaling, stateless workers, checkpoint storage, concurrency, auth, and idempotency.
Capstone: Building the Enterprise Customer Resolution System
The final module — one complete, realistic, production-shaped application, built file by file, using every single mechanism this entire course has taught: state, routing, Send, reducers, subgraphs, interrupts, checkpointing, and tests.
WHY LANGGRAPH?
Make agent behavior explicit, inspectable and recoverable
LangGraph gives agent workflows a durable structure: state is visible, transitions are explicit and long-running work can pause, resume and involve people. That control turns experimental agent loops into systems you can test and operate.