About Walrus Memory
Overview
Walrus Memory is a portable memory layer for AI agents. It runs on Walrus, the Verifiable Data Platform that Mysten Labs created, and gives agents persistent, shared, and independently verifiable memory across sessions, apps, and runtimes.
Developers wire two calls into an agent, one to remember and one to recall, and the SDK handles authentication, encryption, embeddings, and storage on Walrus. Context stops dying when a session ends, so an agent picks up the same memory in a different app, on a different framework, weeks later.
Key Benefits
- Context survives the end of a session, so an agent resumes work in another app or runtime weeks later.
- Owners set programmable delegate permissions that decide which agents read or write each memory, and nothing is shared by default.
- Every memory is encrypted before storage and decrypted only for a signed request from an authorized SDK.
- Multiple agents read and write one shared namespace so they stay coordinated inside multi-step workflows.
- Prebuilt Python, TypeScript, and JavaScript SDKs plus native MCP support drop into the agent stack a team already runs.
- Integrity is independently verifiable on Walrus, so teams can prove a memory has not been tampered with.
How It Works
To write a memory, the SDK sends a signed request and the relayer verifies ownership and access, encodes the text with embedding models optimized for retrieval, encrypts the result, stores it on the Walrus Protocol, and indexes it for semantic search. To recall, the SDK sends a signed query, the relayer pulls the most relevant memories from Walrus, and the payload is decrypted and injected into the model context for downstream reasoning.
Use Cases
- Multi-agent workflows: agents share context across tasks, tools, and time, so what one agent learns becomes available to the whole workflow.
- Customer support agents resume where the last conversation ended and know what was tried, what failed, and what the customer needs.
- Notes and research apps run a second brain that captures ideas continuously and retrieves them naturally weeks later.
- Personal assistants hold on to tone, preferences, routines, and relationships instead of starting over each session.
- Monitoring and infrastructure teams keep prior agent observations, avoid reprocessing the same events, and produce an audit trail of why activity was flagged.
Why Choose This Product
Redis, Postgres, and vector databases give developers storage primitives and leave embeddings, access control, encryption, ownership, and portability to them. Walrus Memory manages those layers directly: each memory ties to a signing key the account holder controls, carries programmable permissions as it moves, and stays verifiable on Walrus, so switching apps or frameworks needs no migrations or adapters.
Walrus Memory Pros & Cons
- Memory persists across apps, sessions, and runtimes
- Memories are encrypted and independently verifiable on Walrus
- Programmable permissions with user-controlled keys and ownership
- Python, TypeScript, and JavaScript SDKs
- Native MCP support and plugins for OpenClaw and NemoClaw
- Usage limits apply to the free launch-period access
Key Features
Portable Memory
Memory persists past the end of a session, so an agent reads the same context from a chat app, a workflow, or another framework entirely.
Programmable Permissions
Ownership and delegate permissions determine which agents access which memories and on what terms, and nothing is shared by default.
Encrypted Storage
Each memory is encrypted before it lands on Walrus and decrypted only when a signed request from an authorized SDK retrieves it.
Semantic Recall
The relayer encodes memories with retrieval-optimized embedding models and returns the closest matches for a recall query.
Verifiable Integrity
Independent verification lets teams prove that a stored memory has not been tampered with.
Native MCP Support
The product ships native MCP support plus first-party plugins for OpenClaw and NemoClaw, so agents connect without adapters.
Python and TypeScript SDKs
SDKs expose remember and recall calls configured with an ed25519 private key, an account ID, and a namespace.
AI Client Setup
One setup command adds Walrus Memory to Claude Code, Codex, Gemini CLI, and other AI clients.
Shared Namespaces
Agents join a common namespace to share memory and hold one source of truth across multi-agent workflows.
Frequently asked questions about Walrus Memory
What is Walrus Memory?
Walrus Memory is a portable memory layer for AI agents. It runs on Walrus, the Verifiable Data Platform, and gives agents persistent, shared, and verifiable memory across sessions, apps, and runtimes.
Why do AI agents lose memory between sessions?
Most agent experiences are session-based: when the chat, app, or runtime ends, the context window disappears with it and the next session starts from scratch. Walrus Memory makes memory portable instead, so an agent picks up where it left off in a different app or runtime weeks later.
How do I give my AI agent persistent memory?
Install the Walrus Memory SDK in Python or TypeScript and wire two calls into your agent, one to remember and one to recall. The SDK handles authentication, encryption, embeddings, and storage on Walrus, so you do not manage vector indexes yourself.
How can I make my agent's memory portable across apps?
Walrus Memory decouples memory from the app the agent runs in by storing every memory on Walrus with programmable permissions that travel with it. The agent authenticates with a signed SDK request and pulls the same memory from a chat app, workflow, or another framework, with no migrations or adapters.
Who owns the memories stored in Walrus Memory?
You do. Every memory is tied to a signing key you control, and only requests signed by that key can read or write it. Permissions are programmable, nothing is shared by default, and no middle layer can read your memories.
Where is memory stored and is it encrypted?
Memory is stored on Walrus, the Verifiable Data Platform. Every memory is encrypted before storage and decrypted only when a signed request from an authorized SDK retrieves it, and integrity is independently verifiable.