Skip to main content

What is Walrus Memory?

Walrus Memory enables AI agents to operate reliably across apps and sessions, without losing context. Portable, verifiable, and fully controlled by you, it's the memory layer that lets agents handle complex workflows and coordinate using data they can trust.

Portable by Design

Memory operates across agents, apps, and workflows without binding to a single runtime or provider

Fully Under Your Control

Programmable permissions and explicit ownership define how memory is shared, accessed, and updated

Built for Agent Coordination

Shared memory spaces help agents coordinate across long-running and multi-step workflows

Verifiable Integrity

Anyone can independently verify memory integrity without centralized trust

Why do agents need Walrus Memory?​

AI agents today lose context between sessions: every conversation starts from scratch. When memory does exist, vendors lock it inside platform-specific databases that the user doesn't control. Walrus Memory solves this by giving agents:

  • Portable memory: Memory persists outside prompts and context windows, moving across agents, apps, and workflows.
  • Full owner control: Programmable access control and explicit ownership, with delegate access for agents and workflows.
  • Agent coordination: Shared memory spaces help agents coordinate across long-running and multi-step workflows.
  • Verifiable integrity: Anyone can independently verify memory integrity without centralized trust.

What are the core features of Walrus Memory?​

Walrus Memory groups its features into memory operations, ownership and access control, and infrastructure.

Memory operations​

Remember

Store memories with semantic understanding. The relayer, the service that handles storage and retrieval behind a basic API, generates vector embeddings so your data is searchable by meaning, not just keywords.

Recall

Retrieve relevant memories using natural language queries. Finds the closest matches based on meaning, scoped to your memory space.

Analyze

Extract structured facts from text automatically. Each fact lands as a separate memory for more precise recall later.

Ask

Query your memories and get an AI-generated answer with the relevant context attached. Combines recall with LLM reasoning.

Ownership and access control​

Decentralized Storage

Walrus stores the blobs, with no single point of failure and no central operator holding your data.

Programmable Permissions

Sui smart contracts enforce ownership and access rules, giving you explicit, programmable control over who can read and write.

Delegate Access

Grant scoped access to other agents, users, or services. The owner manages every grant onchain, enabling agent coordination and cross-app workflows.

Infrastructure​

Restore

Rebuild your index from Walrus if it's ever lost. Rediscovers blobs by owner and namespace, re-embeds only missing entries.

AI Middleware

Drop-in memory for Vercel AI SDK apps. Automatically saves and recalls context around AI conversations.

What's included​

What can you build with Walrus Memory?​

Walrus Memory fits any app where agents need memory that travels with them:

  • AI chat apps: Capture valuable knowledge from conversations so agents remember context across sessions and apps.
  • Multi-agent workflows: Shared memory spaces let agents coordinate on task lists, knowledge bases, and coordination state.
  • Personal AI assistants: Build agents that learn and adapt over time, with memory the user fully controls.
  • Cross-app memory: Let users carry their memory between different apps and services instead of binding them to a single provider.
  • Note-taking and knowledge tools: Save user insights, summaries, and references as portable, verifiable memory.

The example apps show Walrus Memory in action.

Example apps​

The repo ships with ready-to-run apps in the /apps directory:

  • Playground: Dashboard demo for Walrus Memory.
  • Chatbot: AI chat app with portable memory across sessions.
  • Noter: Note-taking tool that stores knowledge as verifiable memory.
  • Researcher: Research assistant that builds and recalls a knowledge base.

See Example Apps for short code examples from each app.

If Walrus Memory is useful to you, a star on the GitHub repo ⭐ helps others find it.

Explore the docs​

Concepts

Memory spaces, ownership and delegates

Architecture

System overview, component responsibilities, core flows, data flow security

SDK

Quickstart, usage patterns, AI integration, and examples

Relayer

Managed relayer, installation and setup, self-hosting

Smart Contract

Onchain ownership model, delegate key management, permissions

Indexer

Event indexing, onchain events, database sync

Reference

SDK API, relayer API, configuration, environment variables

How restore finds missing entries​

Restore treats the blobs on Walrus as the source of truth and the index as a rebuildable cache. For one namespace, the relayer:

  1. Queries the onchain Walrus blob objects you own, filtered by namespace metadata.
  2. Compares them against the local database to find the blobs it already indexed.
  3. Downloads, decrypts, re-embeds, and re-indexes only the missing blobs.

Restore is a recovery operation, not a sync. It leaves already-indexed blobs alone, so it does not rebuild an entry that is already in the index. The response reports those blobs as skipped and reports permanent decrypt or UTF-8 failures as failed. The limit parameter defaults to 10, and the relayer clamps it to [1, 100]. Restore is incremental and idempotent, so you can call it multiple times safely. For the request and response format, see restore in the SDK API reference and POST /api/restore in the relayer API reference.

What are the constraints of Walrus Memory?​

Before you adopt Walrus Memory, check its supported runtimes and fixed design constraints:

  • Runtimes: The SDK initializes entirely from configuration, so it runs in a backend service, a cron job, or an autonomous agent. Walrus Memory also offers a separate Python SDK, which signs requests with your Ed25519 delegate key and sends text over HTTPS. The AI middleware accepts models from AI SDK v4/v5 and v6+.
  • Server-side processing: With the default client, the relayer performs encryption, embedding, and Walrus storage, so it sees your plaintext. To keep plaintext on your side, use the MemWalManual client instead of the default client, or self-host the relayer in a trusted execution environment (TEE).
  • Sui-only ownership: Ownership records live on Sui. Walrus Memory never mirrors a memory onto another chain, and an Ethereum address cannot own a memory account.
  • Storage costs: Walrus charges storage in WAL. Your agent neither holds nor spends WAL when a relayer fronts that cost.