Checkpointed agent state you can list, replay and fork by API.
langchain.com ↗repo ↗docs ↗Persistence / checkpointers ↗Time travel via the server API ↗Frontend time travel (useStream forkFrom) ↗LangSmith Studio (formerly LangGraph Studio) ↗MCP endpoint in Agent Server ↗
The best-specified agent-facing fork/replay API, applied to a different kind of state; scene should copy its verbs and semantics.
Borrow from it: take a specific idea, API or format.
LangGraph made time travel a first-class, boring API for millions of production agent runs: every super-step is a checkpoint with an id and a parent, get_state_history lists them, invoke from a checkpoint replays, and update_state forks — creating a new branch instead of destroying history, with as_node controlling exactly where execution resumes. The same four verbs exist in Python, JS, REST and a React hook (forkFrom), and Studio renders them for humans. It also faced the hard truth scene must face: replay of effectful steps re-executes and may differ, and human-in-the-loop interrupts re-fire — and documented the semantics plainly. A fan would say: this is the exact read/seek/fork/replay contract thc-scene's plan describes, battle-tested at ~12M weekly downloads; copy the verbs and semantics.
| UI as data | 1 scene 5 | Not a UI tool; state is serializable but Studio's UI is not data. |
|---|---|---|
| Agent can drive it | 3 scene 5 | REST/SDK API drives runs and state; MCP exposes runs only. |
| Agent can see it | 4 scene 5 | Structured state at every checkpoint; no rendering. |
| Small, targeted edits | 4 scene 5 | Keyed partial state updates via reducers at a chosen checkpoint. |
| Time travel | 5 scene 0 | Read, seek, fork and replay are all callable by an agent through the API. |
| Live data rate | 2 scene 5 | Streams tokens/updates per step; not a high-rate data tool. |
| Terminal native | 0 scene 5 | |
| Pixel graphics | 0 scene 4 | |
| Teaching | 1 scene 3 | |
| Maturity | 5 scene 1 | ~12M PyPI downloads/week; a standard for agent orchestration. |
| Openness | 4 scene 4 | MIT library; Studio and Agent Server are commercial. |
LangGraph time travel scene now scene planned
Plain Python/JS API and an HTTP API (Agent Server) any agent or tool can call: list history, get state at a checkpoint, update_state (fork), resume (replay). Agent Server also exposes deployed graphs as MCP tools at /mcp, but those tools run the agent; history operations are not exposed as MCP tools.
Low for code: a checkpointer at compile time. For an external coding agent: call the REST API or write SDK code; no off-the-shelf MCP for history.
Full structured state (values, next, tasks, metadata, parent) at every checkpoint; no rendered view (it is not a UI).
update_state with a partial values dict, applied through reducers as a named node, at a chosen checkpoint — targeted, keyed edits that become new checkpoints.
Read (history list), seek (state at checkpoint_id), fork (update_state on a past checkpoint), replay (invoke from a checkpoint) — all API-callable. Replay is re-execution, not deterministic playback.
The clearest complete set of agent-callable history operations found (read, seek, fork, replay), for agent workflow state rather than UI.
A graph of nodes runs in 'super-steps'; with a checkpointer (InMemorySaver, SQLite, Postgres, …) LangGraph persists a checkpoint after each step, keyed by thread_id and checkpoint_id, with a parent pointer. A StateSnapshot holds values (full state), next (nodes to run), tasks, config and metadata. Time travel = resume from any prior checkpoint: replay re-executes downstream nodes (LLM calls fire again); fork calls update_state on a past checkpoint, which writes a NEW checkpoint branching from it (via the named node's reducers) rather than rolling back. The same operations are exposed over the Agent Server REST API and SDKs, and rendered by LangSmith Studio and the useStream frontend hooks.
No published numbers for checkpoint write/read cost or history query speed found. Checkpoints store full state per super-step (with per-channel versioning), so cost scales with state size and step count.
Among the most-used agent orchestration frameworks; checkpointing (and hence time travel) is on in any graph compiled with a checkpointer. first_release is the first PyPI upload (0.0.8, 2024-01-08).
Used by: Klarna, Replit, Elastic (named in README)
Stable 1.x API, very active, company-backed.
Releases: Weekly-ish patches: 1.2.10 (2026-07-28), 1.2.11 (2026-08-11), 1.2.12 (2026-09-21), 1.2.13 (2026-10-05), 1.2.14 (2026-10-06); 1.0.0 on 2025-10-17. CLI and SDK release separately. · Contributors: 289 (GitHub contributors API, incl. anonymous) · Recent: ~151 commits in the last 90 days; pushed 2026-10-09. · Bus factor: high: well-funded company team
Agent-callable read/seek/fork/replay over serializable state with ids and parent pointers — the same verbs scene plans (history, state_at, fork, replay).
The API contract and semantics of branching time travel (fork creates a new branch, never rollback; replay from a point; as-if-produced-by attribution). scene should adopt these semantics rather than invent new ones.
No UI at all: no rendered frame at a checkpoint, no terminal, no live interactive surface for a person, no teaching; time travel is over agent workflow state, not a screen.
| 1–7 | home · features · use cases · docs · changelog · under the hood · blog |
| t | light or dark |
| j k | scroll |
| g G | top · bottom |
| ? Esc | this · close |