TuskPointGitHub

Save agent state to a network that remembers.

TuskPoint is a drop-in LangGraph checkpointer. Every step becomes an immutable Walrus blob — so you can survive a crash, rewind to any moment, and search your run in plain English.

install
$ pip install -e ".[all]"
See a real runBrowse the 8 tools
walrus.certifiedcheckpoint.savedmanifest.linkedrecall.ready

8

MCP tools

2

storage layers

100%

byte-exact reads

0

secrets on-site

manifest wHK1WMSMhPPD…4 checkpoints · stored live on Walrus
  • IMMUTABLE BLOBS✺
  • BYTE-EXACT READS✺
  • REWIND TO ANY STEP✺
  • SEMANTIC RECALL✺
  • SURVIVES A CRASH✺
  • 8 MCP TOOLS✺
  • WALRUS · LANGGRAPH · MEMWAL✺

Agents forget the moment they crash.

Four failures stand between a demo agent and one you can actually operate. 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.

01

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())
02

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
03

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
writerstep 2

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

verifiedbCZT2GNdVPRr3gDzeS…
Inspect, diff & search this run

MCP server · stdio

Eight 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 }

AUDITRead

verify_trail

Audit a thread end-to-end. Re-fetches every content-addressed blob so tampering or corruption shows up as a failed step.

→ { ok, checkpoint_count, verified, 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
   LangGraph agent ──▶ WalrusSaver.put()
                          │
        ┌─────────────────┼──────────────────┐
        ▼                                     ▼
  serialize+gzip+PUT                   build 1-line summary
        │                                     │
        ▼                                     ▼
  ┌──────────────┐                     ┌──────────────┐
  │ Walrus blob  │  ◀── exact reads    │   MemWal     │  ◀── English search
  │ (the truth)  │      by blob id     │ (the index)  │      → 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 — eight 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.

CapabilityIn-memoryMutable DBVector-onlyTuskPoint
Survives a process crash
Byte-exact, content-addressed reads
Rewind to any prior step
Tamper-evident history
Plain-English recall over history
One MCP any agent can call
  • IMMUTABLE BLOBS✺
  • BYTE-EXACT READS✺
  • REWIND TO ANY STEP✺
  • SEMANTIC RECALL✺
  • SURVIVES A CRASH✺
  • 8 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 runHow it works