LangGraph

Core concepts

1. State, nodes, and edges: The whole framework is three primitives — state stores the current snapshot, nodes perform work (call an LLM, run a tool), edges decide what runs next, including conditional branches and loops. LangGraph Docs
2. Why graphs over a single agent loop: Sequential flows, conditional branching, loops, and parallel execution are all explicit in the graph rather than hidden inside one opaque agent loop — easier to debug and reason about at scale.
3. Supervisor and multi-agent patterns: A common pattern is a supervisor node routing work to specialist agent nodes, each operating in its own focused context — directly comparable to the handoffs pattern in OpenAI Agents SDK, but with more explicit control over the routing logic.
4. Durable execution & human-in-the-loop: LangGraph 1.0 emphasizes persistence and the ability to pause a graph for human approval before a sensitive step, then resume exactly where it left off.
5. LangGraph vs CrewAI vs AutoGen: LangGraph is lower-level and more flexible but needs more setup; CrewAI's role-based pattern (each agent has a job title, goal, and tools) and AutoGen are faster to start but less customizable — pick LangGraph when you need fine-grained control, CrewAI for fast iteration on a multi-agent demo.

What Is It?

LangGraph is LangChain's low-level orchestration layer for stateful, multi-step agents.

Supports branching, human-in-the-loop, and persistent checkpoints.

Popular for multi-agent and long-running workflows.

Why Should I Care?

Complex support bots and research pipelines need explicit control flow you can draw on a whiteboard.

Durable execution helps recover from worker crashes mid-task.

Real World Analogy

LangGraph is a subway map for your agent — explicit stations (nodes) and lines (edges) instead of one long taxi ride (single while loop).

Visual Mental Model

[start] -> node A -> node B
              \-> branch C

Beginner Explanation

LangGraph models agents as graphs: state, nodes, edges, checkpoints. Use when flows branch, loop, or need durable execution — not for every hello-world bot.

Smallest Possible Example

# graph: nodes (steps) + edges (transitions)
STATE = {"messages": []}
print("model graph orchestration")

Common Mistakes

❌ Huge graphs nobody can diagram.

If the team cannot sketch it, debugging will hurt.

❌ Storing massive state blobs each step.

Checkpoint costs and latency grow quickly.

❌ Using LangGraph without understanding vanilla tool loops.

Graphs wrap the same primitives — learn loops first.

Real Project Example

LangChain customers orchestrate customer support flows with graphs and human approval nodes.

Multi-agent research demos on LangSmith often export LangGraph traces.

Build This Mini Project

Draw a three-node graph (classify -> retrieve -> answer) on paper, then implement the smallest LangGraph tutorial matching that sketch.

Interview Question

Why use a graph instead of a while loop?

Graphs make branching, parallelism, persistence, and visualization explicit — valuable when workflows are non-linear or must survive restarts; simple loops suffice for straight tool chains.

Key Takeaways

• State + nodes + edges mental model.
• Use for branching/durable flows.
• Keep graphs understandable.
• Checkpoint size matters.

Resources

• LangGraph Docs
• GitHub: langgraph
• LangGraph Announcement Blog
• LangChain Academy: LangGraph (free course)
• CrewAI · AutoGen/AG2 — worth knowing as the higher-level alternatives

YouTube learning

Core concepts from video walkthroughs:

• LangGraph tutorial — state, nodes, and edges
• Multi-agent patterns in practice (workshop)
• MCP + agents (complements LangGraph tool wiring)

The 60-second story

A single clerk with a secret routine is fine until the routine becomes “ask research, then legal, then a human, then maybe research again.” You can no longer see the routine. You can only watch the clerk frown. LangGraph asks you to draw the routine as a graph: boxes that do work, arrows that say what happens next, and a clipboard that holds the current facts.

State is the clipboard. Nodes are the boxes. A node might call a model or run a tool. Edges are the arrows, including arrows that depend on what the clipboard says. A loop is an arrow back to a box you have visited. That sounds formal. It is just a floor plan you can point at when the agent does something weird.

A supervisor pattern is a host who does not cook every dish. The host reads the ticket and sends it to a specialist. Each specialist has a smaller clipboard. That is the same idea as a handoff, drawn so you can see it. Durable execution is the ability to freeze the floor plan mid-shift, especially for a human to approve a refund, and resume without pretending the shift just started. The clipboard was saved.

CrewAI will get you a demo with job titles faster. AutoGen has its own rhythm. LangGraph is the floor plan when you care more about control than about a quick cast of characters. Replit, Uber, LinkedIn, and GitLab did not adopt it because graphs are fashionable. They adopted it because multi-step work got too important to hide.

Map the floor.

• State is the clipboard.
• A node is a box that works.
• An edge is the next box, sometimes chosen.
• A supervisor is a host, not the whole kitchen.
• A pause for approval is freezing the clipboard.
• A loop is an arrow you meant to draw.

# sketch, not a full app
# clipboard in, node updates clipboard, edge picks the next node

You do not need a twenty-line sample to remember the shape. If you cannot draw the boxes, you are not ready to hide them in one agent loop.

Graphs exist because an opaque loop is hard to debug at 1 a.m. Persistence exists because “start over after the human clicks approve” loses the work and sometimes repeats a side effect. The extra setup is the cost of being able to point at the box that misbehaved.

Mental model: a floor plan and a clipboard. If the work is one clerk and three tools, you might not need the plan. If a human has to step onto the floor, draw it.

You have the page if you can say what state, node, and edge are without looking, and why a pause is a feature rather than a crash.