Every AI conversation ends the same way: close the session and the context is gone. Lighthouse Memory, the newest product from decentralized storage protocol Lighthouse, fixes that with three primitives, remember, recall and forget, persisting every memory as a verifiable blob an agent can carry across models, tools and sessions.
The Real Problem: Context Windows Aren’t Memory
Most people assume an AI “forgets” because the model isn’t smart enough to hold onto details. That’s not what’s happening. A context window is everything the model can see in the current conversation. Memory is what persists after that conversation ends. These are two different things, and most AI tooling has never actually separated them.
That’s why the same frustration repeats across every tool: start a new chat and you re-explain your project. Switch from one assistant to another and the new one is a stranger. Come back to the same thread three days later and useful context has already fragmented across sessions you can’t easily stitch back together.
The fix isn’t a bigger context window. A window that holds more still resets the moment the session ends. What’s missing is a persistence layer outside the model itself, somewhere an agent can save what matters and retrieve it later, on demand, regardless of which model or client is running at the time.
How Lighthouse Memory Works
How Lighthouse Memory Works
The public surface is three verbs: remember, recall and forget. An agent connects through one of two paths, a hosted MCP server at memory-api.lighthouse.storage/mcp for any MCP-capable client (Claude Code and Claude Desktop both connect directly), or a TypeScript SDK for custom builds.
The public surface is three verbs: remember, recall and forget. An agent connects through one of two paths, a hosted MCP server at memory-api.lighthouse.storage/mcp for any MCP-capable client (Claude Code and Claude Desktop both connect directly), or a TypeScript SDK for custom builds.
Every memory that gets saved is persisted as a verifiable blob addressed by an IPFS-compatible CID, the same addressing scheme IPFS has always used. You choose the storage backend per store: Walrus, built on Sui, where memories exist as Move objects secured by erasure coding, or Filecoin, with a longer track record and continuous storage proofs (PoRep and PoSt). Retrieval works the same way regardless of which backend holds the data, recall() searches by meaning rather than exact keyword matching, and returns the matching memories with their id, CID, relevance score and tags.
Choosing a Backend: Walrus vs Filecoin
Lighthouse doesn’t force a single storage philosophy. Each memory store picks the backend that fits the workload.
Walrus vs Filecoin
As of August 2026, Lighthouse’s own pricing put Filecoin’s free tier at 5 GB against Walrus’s 100 MB, with entry-level paid plans starting around $12 a month, reflecting Walrus’s higher per-gigabyte cost for its faster retrieval. The practical split: reach for Walrus when an agent needs memories back quickly and often, and Filecoin when the priority is archival durability at the lowest possible cost per byte.
Model-Agnostic by Design
The detail that separates Lighthouse Memory from most memory products bolted onto a single assistant: it never calls a language model itself. It has no opinion about which model is doing the reasoning. An agent can run on GPT, Claude, Llama, Qwen, Mistral or DeepSeek through Ollama or vLLM, recall context from memory, and inject it directly into the prompt.
That matters practically, not just architecturally. A support agent might store “Your staging environment is at staging.acme.dev” from one conversation. Because that memory lives in Lighthouse rather than inside whichever client wrote it, a completely different model asked the same question later returns the same correct answer. Switching tools doesn’t reset what’s been learned.
Under the hood, both supported engines (a batched engine for standard use, and memwal for encrypted memory with Walrus and SEAL) implement the same interface: remember, recall, list, get, forget, status and snapshot. That consistency is what lets Lighthouse Memory function as one shared layer across every model a team happens to be using, rather than a feature locked to one vendor’s ecosystem.
What “Verifiable” Actually Proves, and What It Doesn’t
Because every memory carries an id, a CID, a relevance score and tags, an auditor can reconstruct exactly what an agent knew at the moment it made a decision, not just what it eventually did. That’s a genuine audit capability most memory layers simply don’t offer: poll status() and you can catch pending memories at session end, a keyword fallback where semantic embeddings should have matched, or a stale snapshot CID before it becomes a production problem.
Lighthouse’s own documentation is unusually precise about where that verification stops. A CID proves a memory exists and hasn’t been silently altered since it was written. It does not prove the memory was true when it was recorded. It does not prove the agent recalled the correct memory for the question it was answering. And it doesn’t establish who wrote a memory unless that’s explicitly recorded, which Lighthouse Memory does via an agent field on every entry.
That’s a narrower, more honest claim than most “verifiable AI” marketing makes, and it’s worth taking seriously for exactly that reason. Deletion semantics follow the same precision: on the Lighthouse/Filecoin path, forget() stops the storage period from renewing, the content stays technically readable until that period lapses, then is reclaimed. On Walrus, forget() removes the local copy and unpins the IPFS mirror immediately. Anyone building on this for private or regulated data should pick a backend based on that distinction, not discover it after the fact.
Getting Started
Two integration paths, depending on what’s being built.
For an MCP-capable client like Claude Code or Claude Desktop, connecting is a one-line command pointing at Lighthouse’s hosted MCP server:
claude mcp add lighthouse-memory
–transport http “https://memory-api.lighthouse.storage/mcp”
–header “Authorization: Bearer $LIGHTHOUSE_API_KEY”
Once connected, the agent gains remember, recall and forget as tools it calls on its own, deciding when something is worth saving and when a question calls for retrieving something it already knows.
For a custom agent build, the TypeScript SDK gives direct control:
import { createStorage, createEmbedder } from ‘@lighthouse-ai/core’;
import { BatchedEngine } from ‘@lighthouse-ai/engine-batched’;
import ‘@lighthouse-ai/store-lighthouse’;
import ‘@lighthouse-ai/embed-local’;
const memory = new BatchedEngine(
createStorage(),
{ namespace: ‘my-agent’, embedder: await createEmbedder(‘local’) }
);
await memory.remember(‘Our project uses TypeScript.’, {
tags: [‘stack’],
});
await memory.flush();
const context = await memory.recall(‘What language do we use?’);
That’s the entire surface. No vector database to provision, no schema to design before the first memory is saved.
Where This Is Headed
Lighthouse didn’t arrive at this problem from the AI side. The company spent years running decentralized storage on IPFS and Filecoin, serving a reported 2,000+ teams, with encryption, token gating and gateway infrastructure already in production before “agent memory” was a category anyone was pitching. The June 2026 Walrus integration moved from announcement to full SDK support within a single quarter, a faster shipping cadence than most infrastructure teams manage.
Lighthouse has a token generation event approaching. No official date has been confirmed as of this writing, so treat any specific timeline you see elsewhere as unverified. What’s actually worth evaluating right now is the product itself: a memory layer that’s model-agnostic, backed by a choice of two storage networks, precise about what its verifiability claims do and don’t cover, and already running in production MCP setups today. Whatever the TGE ends up looking like, that’s the part that’s live and testable right now.
Resources
Lighthouse main websiteLighthouse MemoryLighthouse StorageLighthouse Blogs
Your AI Agent Has Amnesia: Inside Lighthouse Memory was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.