what is langgraph
langgraph is langchain's orchestration layer: you model an agent system as a state machine — typed state, functions as nodes, edges as control flow — and the runtime gives you streaming, persistence, and human-in-the-loop pauses for free. langchain supplies the parts (models, tools, messages); langgraph decides how they compose. it's the framework equivalent of the position agentic patterns argues from first principles: the loop is not the hard part, the composition is.
who this is for
engineers who can ship a single working agent — a react loop with tools — and are now staring at the next requirement: more than one. a reviewer that gates an implementer. a triage agent that routes to specialists. a team that runs while you're not watching. typescript throughout, small examples, no notebook required. if you've read the agentic sdlc post and wondered what the machinery looks like, this is that course.
why a framework this time
agentic patterns is deliberately framework-agnostic, and that course still holds. but orchestration is the layer where hand-rolling stops paying: checkpointing a paused graph, resuming mid-run after a human approval, streaming state from four parallel agents — that's plumbing you want to buy, not build. langgraph is the most-adopted way to buy it in typescript, and every pattern in this course maps back onto the vocabulary you already have: personas become nodes, handoffs become edges and commands, guardrails become gates in the graph.
how the lessons work
- each lesson is one orchestration shape with the smallest typescript example that exercises it.
-
we use the real packages —
@langchain/langgraph,langchain,@langchain/core— against the current 1.4-era apis (createAgent, not the deprecated createReactAgent). - every lesson ends with when it breaks — the failure mode you'll meet in production, and how to notice it early.
- lesson eight is the capstone: the sdlc pipeline from the company-of-one post, rebuilt as a graph you can run.
lessons
- 01 why a graph chains run forward, agents loop, teams branch. where langchain ends and langgraph begins — and why orchestration is a state-machine problem. 10m
- 02 state, nodes, edges the whole api surface: an annotated state, functions as nodes, edges as control flow. reducers are where the sharp edges hide. 13m
- 03 tools and the react agent tool() plus zod, createAgent's react loop, and when one call stops being enough. one agent, working, before any team exists. 12m
- 04 the supervisor — teams with a router a team is agents plus a routing decision. the supervisor pattern, handoffs via Command, and why the supervisor should do nothing else. 14m
- 05 swarms — peer-to-peer handoffs no router: agents hand off directly and the active agent is part of the state. when a swarm beats a supervisor, and when it dissolves into chaos. 12m
- 06 subgraphs and fan-out a team as a subgraph, a swarm of workers via Send. map-reduce over agents, parallelism, and keeping team state private. 13m
- 07 human gates — interrupts and checkpoints interrupt() pauses the graph mid-run; a checkpointer makes the pause survivable. approval gates as first-class graph citizens. 12m
- 08 the sdlc as a graph the capstone: refiner → implementer → review gates as a langgraph pipeline, swarms running the sdlc inside your pdlc, and the two decisions that stay human. 15m