LangGraph

What it is and how it works

LangGraph is LangChain's answer to a problem that free-form multi-agent chat frameworks handle poorly: workflows that need to be deterministic, resumable, and inspectable rather than emergent. Instead of letting agents converse until they decide they're done, LangGraph models an LLM application as an explicit state graph — a structure borrowed conceptually from tools like finite state machines and workflow engines, applied to LLM-driven control flow. Nodes in the graph are Python (or JavaScript) functions: they can call an LLM, invoke a tool, run a retriever, or do plain computation. Edges connect nodes, and edges can be conditional — the output of a node (often an LLM's structured decision) determines which node runs next. A shared state object flows through the graph, gets read and mutated by each node, and is what actually threads the "memory" of the execution through the workflow.

This is a meaningfully different abstraction from LangChain's original chain/agent executor model, and different again from swarm-style frameworks (CrewAI, AutoGen) where multiple agents converse in a loop until a termination condition fires. LangGraph's premise is that a lot of real production agent work — a document-processing pipeline, a customer-support triage flow, a multi-step research task with defined checkpoints — has a shape you actually want to draw as a flowchart, with LLM calls sitting at specific decision nodes rather than driving the entire control flow themselves. You still get LLM-directed branching (a node can be "ask the model which edge to take"), but the developer defines the graph topology up front, which makes the resulting system much easier to reason about, test, and debug than an open-ended agent loop.

The architecture's standout feature is native checkpointing. LangGraph persists state at each superstep of graph execution, which means you can pause a run, inspect or edit the state, resume it later, replay it from any checkpoint, or fork it into alternate paths. This is what enables genuine human-in-the-loop patterns — pausing before a consequential tool call for human approval, then resuming — without bolting on a separate persistence layer. Few competing frameworks in the agent-orchestration category treat this as a first-class primitive; most treat human review as an afterthought or require custom plumbing to get it. LangGraph also has a streaming-first design: partial outputs (tokens, intermediate node results) propagate outward as they're produced, rather than requiring the whole graph to finish before you see anything.

Deployment patterns

On a single machine, LangGraph runs as a regular Python (or Node) library — pip install langgraph, define your graph in code, and run it in-process against a local LLM endpoint (Ollama, llama.cpp server, vLLM) or a hosted API. There's no separate service to stand up for basic usage; the graph executes wherever your script runs, and checkpointing can be backed by an in-memory store for development or SQLite for lightweight local persistence across restarts.

For anything beyond a single script, the more common shape is LangGraph embedded inside a backend service — a FastAPI or similar app that exposes the graph as an endpoint, with a proper persistence backend (Postgres is the typical production checkpointer) so that long-running or paused workflows survive process restarts and can be resumed by a different request or even a different machine. This matters specifically because of the human-in-the-loop story: a graph paused waiting for approval needs its state to outlive the request that triggered the pause.

LangChain also offers LangGraph Platform (formerly LangGraph Cloud) and LangGraph Studio as a hosted/commercial layer on top of the open-source library — deployment infrastructure, a visual graph debugger, and managed persistence. That layer is not required to use LangGraph; the core library is fully open-source and self-hostable, which matters for teams running local-only LLM stacks who don't want a SaaS dependency in the loop. A homelab or self-hosted setup typically looks like: local model server (Ollama/vLLM) plus a LangGraph app process plus Postgres for checkpoints, all behind whatever API gateway the team already runs.

How it compares

Against CrewAI, LangGraph trades ease of first use for control. CrewAI's role-based agent/task abstraction gets a multi-agent demo running faster and with less code, but it's fundamentally a looser, more emergent execution model — you're trusting the crew's internal orchestration logic rather than defining explicit transitions yourself. LangGraph's graph definition is more verbose up front but gives you precise control over what happens after every LLM call, which matters a lot once you need to debug why an agent did something unexpected in production.

Against AutoGen (Microsoft), the comparison is similar in spirit: AutoGen's conversational multi-agent pattern is powerful for open-ended collaborative problem-solving between agents, but that same openness makes flows harder to constrain, checkpoint, and audit. LangGraph is the better fit when the business requirement is "this workflow must behave the same way every time it hits this branch," not "let the agents figure out the best path."

Against plain LangChain agents/AgentExecutor, LangGraph is effectively the successor for anything beyond a simple tool-calling loop — LangChain's own docs steer complex flows toward LangGraph now. It composes directly with LangChain's retrievers, tool integrations, and output parsers, so teams already invested in that ecosystem get to reuse most of their existing code rather than rewriting integrations.

Best use cases and honest limitations

LangGraph is the right choice when you need deterministic, auditable control flow with LLM-driven branch points, and especially when human review/approval steps are a hard requirement — its checkpoint/replay primitives are genuinely ahead of most alternatives here. It fits pipelines like document processing, structured research workflows, support ticket triage, and any agentic system a compliance or ops team needs to be able to explain step-by-step after the fact.

It's the wrong choice for quick prototypes where a CrewAI "hello world" would get you a working demo in a fraction of the code, and the learning curve is real — modeling your problem as an explicit graph with typed state requires more upfront design thought than writing a loosely-defined agent loop. Teams that don't need LangChain's broader ecosystem still inherit some of its surface area and dependency footprint. The API has also evolved meaningfully across versions, so pinning versions in production deployments is not optional — breaking changes between minor releases have bitten teams that didn't. Overall: pick LangGraph for production-grade, inspectable agent workflows; look elsewhere for the fastest path to a working multi-agent demo.