Persistent Context for AI Agents: Walrus Memory and Decentralized Storage

If you are currently building production AI agents, you have likely run into the "Goldfish Problem." You build a sophisticated agentic workflow, but as soon as the session ends or the runtime restarts, the context is gone. To fix this, developers usually end up stitching together a patchwork of vector stores, traditional databases, and local state. It works for a few hours, but it starts to buckle under the weight of long running workflows or multi agent coordination.

The fundamental issue is that AI memory has traditionally been volatile or siloed within a single platform. If your agent starts a task in an OpenAI environment and needs to hand it off to a Claude based worker, the context doesn't move with it. This is why we are partnering with Walrus. By moving memory to a decentralized, verifiable storage layer, we are giving agents a way to carry their "brain" across apps, sessions, and providers.

Understanding Decentralized Storage and Walrus

Before we look at the memory layer specifically, it helps to understand the underlying infrastructure. Walrus is a decentralized storage protocol designed for high performance and verifiability. Unlike older decentralized storage models that can be slow or prohibitively expensive for large files, Walrus uses a "blob" storage approach.

In this system, the actual data (the blob) is stored across a network of storage nodes, while the metadata and ownership logic live on the Sui blockchain. This separation of concerns allows the network to scale to petabytes of data while keeping access speeds high enough for real world applications. For a developer, it means you can store massive datasets, like years of blockchain transaction history or complex AI state, and prove that the data hasn't been tampered with since the moment it was uploaded.

Why AI Agents Need MemWal

Walrus Memory, or MemWal, is a specialized layer built on this protocol to solve the persistence problem. It acts as a portable memory layer for AI agents. Instead of memory being an internal variable in a script, it becomes a decentralized asset owned by the developer or the user.

This shift provides three major advantages. First, it offers portability. Memory moves freely across different agents and workflows regardless of the underlying LLM or runtime. Second, it provides explicit control. You can program access permissions, deciding exactly which agents can read or write to specific memory spaces. Third, it ensures verifiability. When an agent retrieves a memory, it can verify the integrity of that context before acting on it. This is particularly important for agents operating in DeFi or handling sensitive on chain operations where a single piece of corrupted data could lead to significant loss.

How to Store and Manage Files on Walrus via Tatum

We have integrated Walrus directly into the Tatum ecosystem to make this as seamless as possible for developers. You do not need to manage complex storage node configurations or handle raw on chain metadata yourself.

The Tatum Storage API provides a straightforward path to upload files, track their status, and manage their lifecycle. Here is the general flow of how it works in practice.

Uploading and Certification

When you upload a file to Walrus through the Tatum API, the process is asynchronous. You send a POST request to the storage endpoint, and the system immediately returns a jobId and a blobId.

At this stage, the file is staged. You then poll the status endpoint using your jobId. The file moves through several states: PENDING, UPLOADING, and finally CERTIFIED. Once it reaches the CERTIFIED state, the file is officially on the Walrus network and is ready for use.

Accessing the Data

Once certified, the API response provides you with download URLs. These URLs allow you to retrieve the file from Walrus aggregator nodes. This is how your AI agents can "read" their memory. Because the data is stored as raw bytes, you can store anything from simple text logs to complex Parquet or CSV files containing structured datasets.

Scaling Beyond Simple Memory

The partnership between Tatum and Walrus also addresses the "RPC wall." Standard blockchain nodes are designed to tell you what is happening right now, but they are notoriously bad at telling you what happened three years ago. If you are training an AI model on historical market behavior, querying a standard node via individual RPC calls is a recipe for rate limits and high costs.

We are using Walrus to package raw on chain data into structured, immutable datasets. This includes years of crypto price data in one minute candles and full transaction histories for Bitcoin, Ethereum, and BSC. By storing these as flat files on Walrus, we allow developers to pull entire datasets directly into their AI models or analytics engines.

This is the foundation of an "AI ready" data layer. Instead of rebuilding historical data pipelines from scratch, you can simply point your agent or model to a specific blob ID on the Walrus network.

Integration with the Model Context Protocol (MCP)

For those looking to integrate this into existing AI workflows, the Tatum MCP (Model Context Protocol) server is a major unlock. It allows you to connect these decentralized memory stores directly to tools like Claude Desktop or other MCP compatible clients.

By using the MCP, your agent can effectively "query" its own long term memory stored on Walrus as if it were a local file or a connected database. This bridges the gap between decentralized infrastructure and the everyday tools that developers are already using to build AI agents.

The goal is to move toward a future where agents are no longer limited by their context window or the session they are running in. By leveraging decentralized storage, we are making persistent, portable context a foundational piece of the Web3 AI stack. Whether you are building an assistant that remembers user preferences across different dApps or an analytical agent that needs to ingest millions of rows of transaction history, the infrastructure is finally there to support it.