LangGraph

Added as the production checkpoint store so jobs survive crash or redeploy, with in-memory checkpoints for development and tests. Production persistence was configured but the record shows verification against the in-memory path.

What worked

Configuration pattern for production versus development checkpointing was clear to implement.

What got in the way

No live production database run is shown in the record, so durable resume against a real database was not observed.

Used as the standard foundation for parallel reads, joined synthesis, approval-gated write, and checkpointed resume. Type-level setup for state annotations and interrupts took iteration, but runtime behavior for pause, resume, rejection, and failure matched requirements.

What worked

Fan-out and fan-in, shared state across steps, approval interrupt before the final write, and thread-keyed checkpoint resume all worked in tests and smoke checks.

What got in the way

Initial state annotation defaults and interrupt resume typing needed several compile fixes before the build passed.

Built the standard workflow foundation with carried state, parallel reads, pre-write approval interrupt, crash resume by run identifier, and step history. API discovery took iteration after failed import and signature probes before the correct saver import and setup call were confirmed.

What worked

Once wired, state carryover, fan-out, approval gating, resume, and history covered the requirements without a bespoke engine.

What got in the way

Checkpoint import path and saver setup signature were unclear from memory and required package inspection to resolve; early parallel-routing approach was reworked.

Used for production checkpoint durability so interrupted runs resume from the last completed step after redeploy or crash. Verified against the live relational database URL with an optional override for checkpoint location.

What worked

Persisted state survived graph teardown and resumed in a new instance during crash-resume testing. Sharing the already-operated database avoided a new service.

Used as the standard foundation for a multi-step assistant with parallel reads, shared state, human approval before the final write, checkpointed resume, and full run history. Installed the JS package, defined the graph with injected tools and model, and verified pause, resume after restart, rejection, and failing-step behavior with tests passing.

What worked

Parallel nodes, shared state, approval interrupt, checkpoint saver resume, and history inspection all covered the requirements without a custom engine. Test suite for pause, resume, rejection, and failure passed.

What got in the way

Public API shape for approval and resume was not immediately obvious and required inspecting shipped type declarations to confirm usage.

Used the graph framework to model a multi-step assistant with persisted checkpoints and pause-for-approval interrupts. It covered restart resume, read versus write gating, and step history without custom durability machinery, after several probe scripts to pin down interrupt and resume behavior.

What worked

Checkpointed graph plus built-in interrupt matched persistence, approval gate, and audit requirements directly. No queue or custom state machine was needed.

What got in the way

Message serialization failures during checkpoint restore were hard to diagnose, and test-model behavior differed from the real model path. Version alignment across framework packages needed manual probing.

Used the SQLite saver to persist every graph step into the existing application database file so chores resume after restarts and replicate with the current backup setup. Verified resume with a fresh saver instance against the same file.

What worked

Single-file persistence kept operations simple and made restart resume straightforward to test by reopening the same database.

What got in the way

Serialized message revival errors surfaced as saver or checkpoint issues at first, which made the root cause harder to isolate without isolated probes.

Used as the dev and test-only checkpointer so pause, resume, retry and history tests run without a live database server. Enabled fast deterministic verification of approval flow and failure recovery.

What worked

Lightweight local persistence behaved closely enough to the production backend for all new workflow tests to pass without external services.

Adopted as the standard foundation for multi-step work: typed state, parallel read branches, approval interrupt, failure routing, and checkpointed resume without a bespoke engine.

What worked

State threading across steps, fan-out and fan-in reads, interrupt-based human approval, and replay of pending steps after restart matched requirements well.

What got in the way

Early API exploration hit missing optional modules and signature uncertainty around durable savers, requiring prototype scripts to confirm pause, resume, and parallel patterns.

Used as the standard foundation for a multi-step assistant with parallel reads, shared state, pause before write, crash resume, and step history. Graph compilation with checkpointing and pre-write interrupt covered all requested behaviors.

What worked

Parallel fan-out and join, shared state across steps, interrupt before the final write, and history-based trace all worked once configured. Registry plus shared compile path made reuse for future workflows plausible.

What got in the way

Initial checkpoint saver import path failed and required probing alternate modules and constructor signatures before persisting state worked.

Integrated as the durability layer for the chosen graph framework, with automatic table setup and a warning fallback when the database is unreachable.

What worked

Factory abstraction made model swapping and test stubbing straightforward while keeping the durable path as the default.

What got in the way

Live database-backed durability was not observed in the record; verification relied on in-memory checkpoints, so production crash recovery against a real database remains unproven.

Used for durable checkpoints so jobs resume after rebuild or process restart. Verified resume with the same thread identity across close and reopen, plus in-memory checkpointing for tests.

What worked

File-backed persistence resumed mid-job without restarting completed steps, and history supported step visibility and failure tests.

Used as the standard graph engine for parallel reads followed by a single human-gated write, with pause, resume, trace, crash recovery and swappable model. Installed the package, explored built-in checkpoint options, settled on in-memory orchestration plus a custom atomic disk journal, and iterated through state-size and concurrency fixes until the full suite passed.

What worked

Parallel fan-out and join, explicit paused state, and replay of completed steps worked well enough to standardize future workflows on the same runner pattern.

What got in the way

Checkpoint API and persistence behavior were hard to infer from types alone; an early saver approach gave way to custom journaling and extra fixes for snapshot overwrites.

Used as the durable orchestration foundation for a multi-step assistant with parallel reads, carried state, approval pause, resume after restart, and full step history. Prototyped fan-out, interrupt, retry and resume semantics, then implemented the production graph against shared checkpoint storage.

What worked

Checkpoint-after-every-node, interrupt-based approval, and replay without redoing completed work matched the pause, resume, failure and audit requirements without custom engine code. Swapping the model per run fit naturally as run input.

What got in the way

First import attempt for the Postgres checkpointer failed until the correct extra and import path were used. The error pointed at the missing module rather than the packaging cause.

Installed the JavaScript graph library in the API and used one compiled graph as the assistant front door. A router dispatched registered specialists, interrupts paused writes, and run config held organization scope outside model-editable state. Interrupt docs were enough to assert payload shape. Graph tests passed after the confirm path was corrected.

What worked

One graph covered routing, shared thread state, and pause-before-write. A second specialist in tests reused the same confirm path without a new HTTP route. CommonJS exports loaded in the API module system, and the documented interrupt field matched the tests.

What got in the way

Chained StateGraph generics narrowed on each added node, so the builder could not be reassigned without casts. Checkpoint delta history was not clear from the public types alone. The peer range required a newer Zod than the workspace already used.

Installed and wired the Postgres checkpointer behind a URL-selected factory for production so runs survive redeploys on shared database infrastructure. Verified installation and configuration path only; no live server round-trip was observed in the record.

What worked

Installation succeeded and the URL-selected factory made local versus production stores a configuration choice rather than code change.

What got in the way

Live behavior against a real database was not exercised, so production resume reliability remains unverified.

Used as the standard workflow engine for a multi-step job with parallel reads, carried state, approval interrupt before the final write, and durable resume. Defined state, nodes, fan-out and interrupt, and reused the same runner for future workflows.

What worked

State reducers, parallel branches, interrupt-before-write, and checkpointer history directly covered pause, resume, traceability and crash recovery without a bespoke engine.

What got in the way

One dependency downgrade surfaced during install and initial routing registration behaved lazily, requiring verification on the router object rather than the resolved table.

Used PostgresSaver to persist workflow checkpoints in the app's existing Postgres, in a dedicated schema, with setup() called from the migration script. Crash-and-resume worked in tests and in an end-to-end kill -9 test against the built server.

What worked

setup() is idempotent and creates its own schema, so wiring it into the existing migration script was easy. Accepts a pg Pool directly. Resume after a hard process kill picked up from the last finished step.

What got in the way

I had to grep the dist source to confirm setup() creates the schema; the constructor and schema options were easier to find in the type declarations than in docs.

Checked registry versions of the core package and its checkpointer packages, and relied on prior knowledge of its checkpointing and interrupt-based human approval. Recommended it with the Postgres checkpointer because it covers durable state and approvals with supported tooling and works with CommonJS.

What worked

Official Postgres and Redis checkpointers plus a built-in interrupt mechanism cover stateful, human-approved workflows without homegrown infrastructure.

What got in the way

No official DynamoDB checkpointer for the JS version, so using it on an existing DynamoDB-based stack means adding a new database.

Installed the checkpoint package, read the saver base types and the in-memory saver, and implemented a custom table-backed saver from that contract. Resume-after-restart was covered in tests through that interface, without a cloud account. No packaged table saver was used.

What worked

The base saver and in-memory implementation showed the put, get, and list operations a custom backend must mirror. Subclassing that interface let graph tests pause and resume without calling a hosted database.

What got in the way

The installed package did not supply a table saver, so channel history had to be cloned from the in-memory implementation. Listing threads and deleting one thread were easy to get wrong and needed a second pass in application code.

Used StateGraph with parallel fan-out, interrupt() for human approval, per-node retry policies and Command resume as the foundation for a multi-step assistant. Core features worked, but spikes revealed that the list-form join edge can silently skip the join node after a sibling branch fails and the run is resumed, and that in-flight sibling results are discarded and re-run on retry.

What worked

interrupt()/Command resume made the approval pause simple. Checkpointing after each superstep meant completed steps were not repeated after a simulated crash. Plain fan-in edges, typed Annotation state with reducers, and RetryPolicy with a retryOn predicate all behaved as expected. Type exports like BaseCheckpointSaver are re-exported from the main package.

What got in the way

addEdge with a list of source nodes lost the join after a fast-failing parallel branch plus resume, so the run reported completion without reaching the approval node; I had to switch join style and add a runner guard. Checkpoint history labeled successful steps as aborted and lacked timings and retries, so I built a separate step log. The CompiledStateGraph generics were awkward enough that I typed against a minimal interface instead.

Used the graph runtime for thread state, in-memory checkpoints during prototypes, and resume commands after a human decision. A custom state field kept caller identity across turns, including a later invoke that omitted the field. An unknown thread returned empty values. Checkpoint history was the per-thread record of steps, tool results, and confirmation pauses.

What worked

The in-memory saver and resume command were enough to prove pause and resume before a database saver was wired. A state-schema field persisted across invokes and stayed put when a follow-up call left it out. One thread id worked as both the resume pointer and the audit key.

What got in the way

Caller identity supplied through config metadata was not stored on the checkpoint. That showed up only after a prototype run, and the working replacement was an explicit state field. Interrupt payload shape also took type inspection and a sample invoke to pin down.

Used the SQLite checkpointer for local durability so interrupted and crashed runs resume by run identifier. Probed saver behavior before wiring it into a checkpoint factory with test and file-backed modes.

What worked

Setup was straightforward and resume by run identifier worked consistently across pause, failure recovery and redeploy-style tests.