LangGraph

LangGraph is an open-source orchestration framework and runtime, developed by the LangChain team, for building stateful and long-running AI agents. It models an application as a graph: each node is a unit of work — often an LLM call or tool invocation — and edges describe how control and state flow between them. Unlike pipelines restricted to a directed acyclic graph, LangGraph supports cycles, so an agent can loop, retry, and reflect until a condition is met. The framework's core claim is that agent behavior should be an explicit, inspectable structure you drew, not an emergent property of a prompt you hope holds together.

State and durability

Every node receives the current shared state, returns a partial update, and the framework merges that update according to developer-defined reducers — so two nodes can append to a message list or overwrite a scalar without trampling each other. With a checkpointer attached (for example Postgres or SQLite), this state becomes durable: an agent run can crash and resume, be paused for hours, or be rewound to an earlier step and replayed down a different branch. Durability is also what makes human-in-the-loop patterns practical — a graph can halt at a designated node, wait for a person to approve or edit the pending action, and continue — which is exactly the checkpoint you want before an agent touches anything irreversible.

The control-flow toolbox

Conditional edges route execution based on the state — retry on failure, escalate on low confidence, finish on success. Cycles let an agent alternate between reasoning and tool use in the style of the ReAct pattern until the task resolves, with an iteration cap as a safety rail. Subgraphs compose: a research agent, a writing agent, and a review agent can each be a graph, wired into a supervisor graph that delegates among them. Because every step reads and writes visible state, debugging an agent becomes reading a transcript of state transitions rather than staring at one enormous prompt — a difference anyone who has debugged either will appreciate.

Where it fits in a sovereign stack

LangGraph can be used standalone and does not require the rest of LangChain to operate. It is model-agnostic, which matters here: the same graph can call a hosted API or a local model served through Ollama or a vLLM endpoint, so an agent developed against a cloud model can be repointed at your own hardware. For self-hosters the durability story is the quiet win — checkpointing agent state to a Postgres instance you run means the full reasoning record, tool calls, and intermediate data stay on your infrastructure instead of in a vendor's observability cloud. Pair it with a local model, a self-hosted vector database for RAG, and your own tools, and the entire agent loop runs inside your walls. It is one of several frameworks a sovereign AI builder might evaluate — the right tool depends on the workload and the surrounding stack, and the graph abstraction carries a learning curve that simple single-shot tasks do not justify.

Two practical notes for builders. Streaming matters for interactive agents — LangGraph can emit state updates and tokens as they happen, so a UI can show the agent working instead of freezing until the graph completes. And version your graphs like code: a durable checkpoint written by one version of a graph must still make sense to the version that resumes it, a small discipline that saves real pain in long-running deployments.

For neighbouring concepts, D-Central maintains entries on the underlying ReAct reasoning-and-acting pattern and on CrewAI, another open-source multi-agent framework. We describe these tools neutrally so readers can choose what best fits their own self-hosted setup.