Save agent state to a network that remembers.

TuskPoint is a drop-in LangGraph checkpointer. Every step is saved as a verifiable Walrus blob, so your agents survive a crash, roll back to any moment, hand a run to another agent, and search their own history in plain English.

install1 / 6

$ pip install -e ".[all]"

Successfully installed langgraph-checkpoint-walrus

$ python scripts/check_walrus.py

PUT blob → publisher.walrus-testnet …

GET blob ← aggregator … bytes identical ✓

$ python demo/run_demo.py --real --part2

fresh process — no state in memory

resumed from Walrus → run completed ✓

$ python demo/run_demo.py --rollback

history preserved: 4 → 5 (append-only)

live head is the restored state ✓

$ python demo/run_demo.py --handoff

Agent A → descriptor (blob + sha256)

Agent B adopted — hash verified ✓

$ python mcp_server/server.py

tuskpoint · stdio · 11 tools ready

Install the package

See a real run Browse the 11 tools

walrus.certifiedcheckpoint.savedmanifest.linkedrecall.ready

MCP tools

storage layers

100%

byte-exact reads

secrets on-site

manifest wHK1WMSMhPPD…4 checkpoints · stored live on Walrus

VERIFIABLE BLOBS✺
BYTE-EXACT READS✺
ROLL BACK TO ANY STEP✺
CROSS-AGENT HAND-OFF✺
SEMANTIC RECALL✺
SURVIVES A CRASH✺
11 MCP TOOLS✺
WALRUS · LANGGRAPH · MEMWAL✺

Agents forget the moment they crash.

Four failures stand between a demo agent and one you can actually run in production: no durable history, no way to rewind, state you can't trust, and memory you can't query. TuskPoint closes all four.

/01

No reliable history

When a long-running agent dies, the in-memory graph state dies with it. There is no durable, addressable record of what it knew at each step.

/02

Can't rewind

Even with logs, you cannot rehydrate the exact state at step 7 and continue. Replaying from scratch is slow, costly, and often non-deterministic.

/03

State you can't trust

Mutable databases let history be quietly rewritten. You need the byte you wrote to be the byte you read back — content-addressed, not best-effort.

/04

Memory you can't query

Vector stores recall fuzzy text, but they aren't the source of truth. You want to ask in English and still land on an exact, loadable checkpoint.

How it works

Three lines from crash-prone to durable.

TuskPoint slots into an existing LangGraph app and turns every step into verifiable, on-network state.

Wrap your graph

Pass WalrusSaver to compile() like any LangGraph checkpointer. No new APIs to learn — your nodes don't change.

graph.compile(checkpointer=WalrusSaver())

Every step is stored

Each checkpoint is gzipped and written as an immutable Walrus blob, linked into a thread manifest with its parent and a summary.

checkpoint → walrus.blob → manifest

Rewind, fork, recall

Resume after a crash, fork any checkpoint into a new branch, or ask your run a question in plain English via MemWal.

saver.search_history("when did the writer start?")

Real run · not a mockup

Every step, an immutable receipt.

These are real checkpoints from one researcher → writer run. Each blob ID below resolves to the exact bytes that were written — click any to verify on the public aggregator.

This run, and the live dashboard, run on the Walrus testnet (free writes), so blob links resolve on the testnet aggregator. The same engine runs unchanged on mainnet — point WALRUS_PUBLISHER_URL / WALRUS_AGGREGATOR_URL at mainnet for paid, production writes.

manifestwHK1WMSMhPPDehX8slPGMRZZ3nPaG0K18_ScVo4fBHAthreadrun-43312

__input__step -1

the graph received its initial input.

verified5HhjbJfw-cWJyQw8WO…

researcherstep 0

state advanced (step 0); channels now set: topic.

verified1Z2dmG6pKcyns4MUjb…

researcherstep 1

state advanced (step 1); channels now set: sources, topic.

verifiedRGaZhhHY1K-oMBHpQ9…

writerstep 2

state advanced (step 2); channels now set: report, sources, topic.

verifiedbCZT2GNdVPRr3gDzeS…

Inspect, diff & search this run

MCP server · stdio

Eleven tools, any agent can call.

A complete checkpoint API over the Model Context Protocol — it complements, and never duplicates, MemWal's own MCP.

Read the docs

PUTWrite

checkpoint_save

Serialize agent state, gzip it, and store it as an immutable Walrus blob. Also writes a one-line summary to MemWal.

→ { checkpoint_id, blob_id, thread_id }

GETRead

checkpoint_load

Load a specific checkpoint by ID (or the latest). Deterministic, content-addressed read straight from Walrus.

→ { state, checkpoint_id, blob_id }

LSRead

checkpoint_list

List every checkpoint for a thread, newest first, with lineage, timestamps, and summaries from the manifest.

→ { count, checkpoints[] }

RESRead

checkpoint_resume

Rehydrate the latest state so an agent can continue exactly where it left off after a crash.

→ { state, checkpoint_id }

DIFFRead

checkpoint_diff

Compare two checkpoints and report exactly what was added, removed, or changed between them.

→ { added, removed, changed, human_readable }

FINDDiscover

checkpoint_search

Ask a question in plain English. MemWal returns the nearest checkpoint summaries — pointers you then load exactly.

→ { results: [{ text, distance }] }

FORKWrite

checkpoint_fork

Git-branch an agent run. Copy any checkpoint into a new thread to replay a different path — the original stays untouched.

→ { new_thread_id, checkpoint_id, blob_id, forked_from }

UNDOWrite

checkpoint_rollback

Durable, auditable undo. Re-writes an earlier checkpoint's state as a new head of the same thread — append-only, so history (and the audit trail) stays intact.

→ { checkpoint_id, restored_from, blob_id, rolled_back_from }

HANDWrite

handoff_checkpoint

Emit a tiny portable descriptor (blob id + SHA-256 + provenance) so another agent can adopt this exact state. No state is copied — only the Walrus pointer and its hash cross the boundary.

→ { source, blob_id, blob_sha256, to_agent }

ADOPTWrite

adopt_checkpoint

Adopt a handoff descriptor: re-fetch the blob from Walrus, verify its SHA-256 against the sender's, and write it as the genesis of a new thread. A tampered blob is rejected before it becomes state.

→ { adopted_from, new_thread_id, checkpoint_id, verified }

AUDITRead

verify_trail

Audit a thread end-to-end. Re-fetches every content-addressed blob and recomputes its SHA-256, so tampering or corruption shows up as a FAIL step — cryptographic, not just a successful fetch.

→ { ok, checkpoint_count, verified, tampered_count, steps[] }

How it works

Two layers, one source of truth.

Exact for trust. Semantic for discovery. Walrus for durability. Vector recall is only ever an index into the exact store — never the source of truth.

01Intercept

Agent takes a step

Your LangGraph agent advances. WalrusSaver.put() intercepts the new checkpoint — no agent code changes required.

02Persist

Serialize → gzip → Walrus

State is serialized with LangGraph's serde, gzipped, and PUT to a Walrus publisher. You get back an immutable blob ID.

03Index

Summarize → MemWal

A one-line natural-language summary is written to MemWal so the run becomes semantically searchable.

04Recover

Resume or rewind

Know the ID? Load it exactly from Walrus. Only a vague memory? Search MemWal in English → get the ID → load exactly.

data flow

source

LangGraph agent

advances one step

intercept

WalrusSaver.put()

no agent code changes

serialize · gzip · PUT

the truth

Walrus blob

immutable, content-addressed

← exact reads by blob id

build 1-line summary

the index

MemWal

semantic recall layer

← search in English → returns ids

manifest blob id cached locally in .walrus_threads.json

LangGraph

Agent framework — TuskPoint plugs into its checkpoint API.

Walrus

Decentralized blob storage — the durable source of truth.

MemWal

Semantic memory — natural-language recall over history.

MCP

Model Context Protocol — eleven tools any agent can call.

Why TuskPoint

Exact for trust. Semantic for discovery.

Other approaches give you one or the other. TuskPoint keeps an immutable Walrus blob as the source of truth and treats vector recall as an index into it — never a replacement.

Capability	In-memory	Mutable DB	Vector-only	TuskPoint
Survives a process crash
Byte-exact, content-addressed reads
Rewind to any prior step
Tamper-evident history
Hand a run to another agent
Plain-English recall over history
One MCP any agent can call

VERIFIABLE BLOBS✺
BYTE-EXACT READS✺
ROLL BACK TO ANY STEP✺
CROSS-AGENT HAND-OFF✺
SEMANTIC RECALL✺
SURVIVES A CRASH✺
11 MCP TOOLS✺
WALRUS · LANGGRAPH · MEMWAL✺

Try it

See it survive
a crash.

Walk through a real researcher → writer run: inspect each checkpoint, diff two states, and search the run's history in plain English.

Open the run How it works

Save agent state to a network that remembers.

Agents forget the moment they crash.

No reliable history

Can't rewind

State you can't trust

Memory you can't query

Three lines from crash-prone to durable.

Wrap your graph

Every step is stored

Rewind, fork, recall

Every step, an immutable receipt.

Eleven tools, any agent can call.

checkpoint_save

checkpoint_load

checkpoint_list

checkpoint_resume

checkpoint_diff

checkpoint_search

checkpoint_fork

checkpoint_rollback

handoff_checkpoint

adopt_checkpoint

verify_trail

Two layers, one source of truth.

Agent takes a step

Serialize → gzip → Walrus

Summarize → MemWal

Resume or rewind

LangGraph

Walrus

MemWal

MCP

Exact for trust. Semantic for discovery.

See it survivea crash.

See it survive
a crash.