LangGraph Course
LangGraph is the framework for building agents as explicit state graphs instead of prompt chains that loop until something breaks. This course covers nodes, edges, state reduction, checkpointing, persistence and human-in-the-loop approval, then production concerns like streaming, retry semantics and testing graphs without a live model.
LangGraph is the framework for building agents as explicit state graphs instead of prompt chains that loop until something breaks. This course covers nodes, edges, state reduction, checkpointing, persistence and human-in-the-loop approval, then production concerns like streaming, retry semantics and testing graphs without a live model.
- State graphs, not prompt chains
- Checkpointing and time travel
- Human-in-the-loop approval gates
- Graphs tested without live model calls
- Modules
- 8
- Format
- Online
- Mentorship
- Weekly 1:1
- Project
- Production
Why this track
What you get that a general AI course does not cover.
Make agent control flow explicit
A prompt chain hides its control flow inside the model. A graph puts every decision, retry and branch in code you can read, log and step through, which is the difference between an agent you can debug and one you can only restart.
Interrupt and resume without losing state
Checkpointing means a long-running graph can pause for human approval or a slow external call and resume exactly where it stopped, instead of replaying from the beginning and paying for it twice.
Cycles are the point
Most agent frameworks assume a DAG. Real work loops: refine, verify, retry, escalate. LangGraph handles cycles as a first-class case with explicit state reduction, so you can reason about termination instead of hoping for it.
Test the graph, not the output
You assert on transitions and state, with the model call stubbed. That makes agent tests fast, deterministic and free, instead of flaky assertions on generated prose.
Curriculum
Eight modules, each ending in something you can show.
- M01
Why graphs instead of chains
The failure modes of ReAct-style loops: unbounded tool loops, lost state, no way to resume. How a state graph fixes each one.
- Chain vs graph
- Unbounded loops
- State as the source of truth
- When a chain is still enough
Tools
- LangGraph
- Python
- M02
Nodes, edges and state
Building the first graph. Typed state, reducers that merge concurrent updates, and routing edges driven by state rather than a hardcoded order.
- State schema
- Reducers
- Conditional edges
- Typed channels
Tools
- LangGraph
- M03
Checkpointing and persistence
Persisting state across runs, resuming interrupted graphs, and using time travel to inspect or replay what an earlier state did.
- Checkpointers
- Thread state
- Time travel
- State history
Tools
- SqliteSaver
- PostgresSaver
- M04
Human-in-the-loop
Interrupting before a risky action, collecting structured feedback, and resuming. Approval gates for tool calls that touch real systems.
- interrupt()
- Command resume
- Approval gates
- Structured feedback
Tools
- LangGraph
- M05
Memory and context management
Short-term thread state versus long-term store. Summarisation, trimming and retrieval so a long conversation does not blow the context window.
- Thread vs store
- Summarisation
- Trimming
- Cross-session recall
Tools
- LangGraph
- LangChain
- M06
Streaming and observability
Streaming tokens and state updates to the user, and tracing graph execution so you can see which node consumed the tokens and the latency.
- Streaming modes
- Token streaming
- State streaming
- Tracing
Tools
- LangSmith
- LangGraph
- M07
Reliability patterns
Retries with backoff, node-level error boundaries, idempotency for tool calls, and designing termination conditions that actually terminate.
- Retry policy
- Error boundaries
- Idempotency
- Termination
Tools
- LangGraph
- M08
Testing and deployment
Testing graphs with a stubbed model, running graphs inside a web service, and shipping one that survives real traffic.
- Graph unit tests
- Model stubbing
- Serving
- Production hardening
Tools
- pytest
- LangGraph
- FastAPI
Roles this maps to
Where this track lines up with real job descriptions.
AI Agent Engineer
Build agents that take actions in real systems with approval gates and resumable state, instead of demos that break on the third tool call.
LLM Application Engineer
Own the control flow of an LLM product: routing, fallbacks, retries and cost, all in code rather than inside a prompt.
AI Workflow Engineer
Turn a messy internal process into a resumable, auditable graph that a human supervises.
Platform Engineer
Standardise how teams build and deploy stateful agent workflows, with consistent tracing and test patterns.
What you can do afterwards
Concrete capabilities, not a certificate.
- Build multi-node agent graphs with typed state and conditional routing
- Add checkpointing so a graph resumes after a crash or a human pause
- Design approval gates for tool calls that touch production systems
- Test agent logic deterministically with the model call stubbed out
- Trace token cost and latency per node, not just per request
Questions
Do I need LangChain to learn LangGraph?
No. LangGraph works standalone, and this course treats it that way. LangChain is covered separately, and it is worth learning both since most production code uses them together.
Is this a LangChain course in disguise?
It overlaps, but the subject is different. LangChain is a component library; LangGraph is a control-flow and state model. We spend most of the time on state, cycles and persistence.
Which Python version do I need?
3.11 or newer. We use modern typing syntax throughout, and the graph examples assume a current LangGraph release.
Will the patterns still apply if the API changes?
The graph model, checkpointing and human-in-the-loop patterns have been stable across releases and predate the current API. We show the concepts so they survive a version bump.
Related tracks
Ready when you are
Applications for the next cohort are open. You pick your track during the first month, so you can change if the material does not suit you.