A graph, a state object and a checkpointer
The LangGraph overview calls it a low-level orchestration framework and runtime for long-running, stateful agents. In plain terms: you declare nodes (ordinary functions), edges between them, and a state schema. You compile that into a graph and invoke it. The docs' hello world is a StateGraph with MessagesState, one node and edges from START and END. Nodes can be hand-written code or LLM calls, in the same graph. The docs say LangGraph does not abstract prompts or architecture, which is a polite way of saying the design is yours.
Install is pip install -U langgraph. agenttooldrop.com lists it as MIT licensed, Python first, with LangGraph.js for JS and TS. The docs say it was inspired by Pregel and Apache Beam, with an interface borrowed from NetworkX. LangChain Inc builds it, but you can use it without LangChain.
You may already be running it without knowing. Per the docs, Deep Agents is built on LangChain agents, which run on LangGraph. That layering is a useful mental model: LangGraph is the runtime, and the model is a swappable part.
Why checkpoints and interrupt() are the actual product
The docs list persistence first: agents that survive failures and resume where they left off. Human-in-the-loop means you can inspect and modify agent state at any point. Ajay Kumar's comparison explains the mechanism: every step writes a checkpoint keyed by thread_id, which makes pause, resume, time travel and human approval cheap to add.
That matches what we would want in production. Put an approval gate in front of a destructive tool call, let the process sit for two days, resume when someone clicks. Without checkpoints you build that yourself, and it is always more work than it sounds.
The other half of the pitch is mixing deterministic and agentic steps in one graph. The docs say this keeps parts of the logic predictable and auditable. We agree with the instinct. Most real agent systems are mostly plain code with a few model calls. If yours is almost entirely deterministic, ask first whether n8n, Make or plain Node.js is enough. A graph framework is not free.
Thirty lines where five would do, plus a platform nudge
The cost is verbosity. Ajay Kumar says a simple tool-calling loop is thirty lines in LangGraph where other frameworks need five. That is his estimate, not a benchmark, and we have not measured it. It feels right, though. The docs themselves call LangGraph very low-level and tell newcomers to start with LangChain's prebuilt agents.
Then there is the ecosystem pull. The overview points you at LangSmith for tracing, LangSmith Engine for monitoring, LangSmith Deployment for hosting and Fleet for no-code agents. The core library is MIT and stands alone. But the documented path to hosting and debugging runs through the vendor's products. The sources we read state no pricing for them, so check before you plan around it.
Two smaller cautions. The docs name Klarna, Uber and J.P. Morgan as users, which is the vendor's claim, and it does not say what they run on it. And the release pace is brisk: 1.2.16 on 16 October per Ajay Kumar, and Agent Guides lists Python 1.2.18 as of 28 October. Pin your versions. The 43,540 stars Ajay Kumar counted on 20 October are attention, not health. He says so himself.
LangGraph against CrewAI and the OpenAI Agents SDK
Ajay Kumar's useful axis is how much control flow the framework hides. LangGraph hides almost nothing. CrewAI hides more: role-based agents with goals and backstories, grouped into crews. It demos quickly and is easy to explain to non-engineers. He also says a crew that takes an odd path is harder to debug than an explicit graph. CrewAI has since added event-driven Flows for the deterministic parts, which suggests the market agrees.
The OpenAI Agents SDK sits at the small end. Agent Guides lists handoffs, guardrails, sessions and tracing, and notes there is no graph engine. We covered the trade in our OpenAI Agents SDK teardown: a small API where durability is your job. If you live in the Microsoft world, see Microsoft Agent Framework. agenttooldrop.com lists it with graph workflows and checkpointing too.
Ajay Kumar's observation is that several frameworks now converge on a state machine with durable checkpoints. We think that is right, and it makes LangGraph the most explicit version of an idea that is becoming the default. Note that agenttooldrop.com says plainly that nothing in its guide is a benchmark. None of these comparisons tells you which framework gives better answers.
Strengths, weaknesses, where it fits
Strengths
- Checkpoints per step make pause, resume and failure recovery cheap
- Human-in-the-loop approval is a first-class primitive, not a bolt-on
- Deterministic code and LLM steps live in one auditable graph
- Works without LangChain, in Python and JS/TS
Weaknesses
- Verbose for simple loops: Ajay Kumar estimates thirty lines against five
- Hosting and debugging point toward paid LangSmith products, pricing unstated in our sources
- Frequent releases, so version pinning matters
- Low-level by design, so architecture decisions are yours
Where it fits
- Approval gates before destructive tool calls
- Multi-day workflows that must resume after a crash
- Audited processes mixing fixed business rules with model decisions
- Teams already tracing with LangSmith
Verdict: We would put it in production for agents that need durable state and human sign-off, with versions pinned. For a quick tool-calling prototype, pick something smaller.
Sources
- LangGraph overview - Docs by LangChain · LangChain
- AI agent frameworks compared: language, control, license · agenttooldrop.com
- AI Agent Frameworks Compared (2026): LangGraph, CrewAI, ADK and 7 More · Ajay Kumar
- Framework Comparison | Agent Guides · Agent Guides
Want this working in your stack, not just in a demo?
We are two senior engineers who build ai workflow automation with a fixed price per written scope.