LangGraph 1.0 released

Background

An agent is a program in which a language model does more than produce a single answer: it decides what to do next, calls tools, and keeps working over a series of steps. Building a demo of this is easy; running it as a real application is not. A single run may wait on an outside service, stretch over a long period of time, or need a person to check something before it continues. If the program keeps its progress only in memory, any interruption throws the work away and the run starts again from the beginning. Agent frameworks therefore have to handle state: where a run has got to, what it has already done, and how to pick it up again. That is what "durable" means in this context — the run outlives the process that was executing it.

What happened

LangGraph 1.0 was released as generally available on 23 October 2025 ^[1]. It arrived one day after LangChain 1.0, which became generally available on 22 October 2025 ^[1]. LangChain described LangGraph 1.0 as the first stable major release in the durable agent framework space ^[2].

Reaching 1.0 carries a specific meaning in version numbering: it conventionally marks the point at which an interface is treated as settled, so that code written against it is not expected to break with each new release. LangChain made that explicit for this line, promising no breaking changes until 2.0 ^[2].

What the release added

The centre of the release is durable state. An interrupted or restarted run resumes where it stopped instead of losing its context ^[2]. In practice this covers the ordinary failures of production software: a process that is redeployed, a machine that goes down, a long job that has to be paused overnight. The run does not replay everything from the start; it continues from the last recorded point.

Built-in persistence supports this. Workflows can be saved and resumed without teams writing custom database logic of their own ^[2]. Saving intermediate progress is exactly the kind of work that is tedious and easy to get subtly wrong, so having it inside the framework rather than bolted on by each application changes how much plumbing a project needs before it can run reliably.

The release also gives human-in-the-loop patterns first-class support in the API: execution can pause for review, modification or approval ^[2]. This matters for any agent that takes consequential actions. Rather than letting a chain of steps run to the end and inspecting the result afterwards, a developer can define a point where the run stops and waits for a person to look at what it proposes, change it, or approve it, and then carry on.

Iteration and users

LangChain said the release followed more than a year of iteration, and named Uber, LinkedIn and Klarna among the users of the framework ^[2]. Those are large organisations running software at scale, which is the setting where resumable runs and approval steps stop being conveniences and become requirements.

Why it matters

Two things make a 1.0 release an event rather than a routine version bump. The first is the stability promise: teams deciding whether to build on a framework weigh the cost of having to rewrite their code when the API shifts, and a commitment of no breaking changes until 2.0 removes part of that risk ^[2]. The second is the category framing. By calling this the first stable major release in the durable agent framework space, LangChain was describing a kind of software — frameworks whose job is to keep agent runs alive, resumable and checkable — as having reached a settled form ^[2].

The timing adds to this. LangGraph 1.0 and LangChain 1.0 landing on consecutive days, on 22 and 23 October 2025, presented the two as a pair rather than as unrelated projects, with the framework for durable agent runs and the surrounding tooling arriving together ^[1].

What the release does not settle is anything about how well agents behave. Durable state, persistence and approval hooks are infrastructure: they determine whether an agent can be run and supervised, not whether its decisions are good. The engineering problem of keeping a long run alive is now addressed by the framework; the rest remains with the application built on top of it.