Memory Architecture Engineering: Tiered Memory for Production Agents
Memory Architecture Engineering: Tiered Memory for Production AI Agents
In April 2026, Anthropic shipped Memory Stores for Claude Managed Agents as a public beta. At the same time, Google Research published their Titans architecture and MIRAS framework, introducing deep neural network-based memory modules. And ACL 2026 saw two major papers - MAGMA and GAM - both proposing graph-based agentic memory architectures.
Memory architecture is evolving fast. This post covers the three approaches we track most closely.
Anthropic's Memory Stores
Anthropic's Memory Stores are built on a deceptively simple idea: mount memory into the agent session as a filesystem directory. The agent interacts with it using ordinary file tools - bash, read, write, edit, glob, grep. There are no dedicated memory tools.
Each store is a workspace-scoped collection of small text documents (up to 100KB each, and Anthropic recommends many small files over a few large ones). When a store is attached to a session, it is mounted at /mnt/memory/ and the agent gets a system prompt note telling it the mount exists.
Every mutation to a memory produces an immutable memory version, giving you a full audit trail and point-in-time rollback and redaction. Each version records the actor (session, API, or user), the operation (created, modified, deleted), and a timestamp.
Key architectural decisions in the Memory Stores API:
- Max 8 memory stores per session. You attach multiple stores for different slices with different lifecycles - for example, one read-only shared reference store plus one read-write per-user store.
- Stores support retrieve, update, list, delete, and archive. Archiving makes the store read-only - existing sessions keep their attachments, new sessions cannot reference it.
- Memory stores attach at session creation time only. You cannot add a memory store to a running session.
- Access can be read-write or read-only, enforced at the filesystem level on the mount.
The production patterns Anthropic recommends: use memory for per-customer or per-entity facts that persist across sessions, scope memory so that one user's data never leaks into another user's session, expire memory entries when their underlying source of truth changes, and audit memory writes the same way you would audit database writes.
Google's Titans and MIRAS
Google Research took a fundamentally different approach. Their Titans architecture treats long-term memory as a deep neural network (specifically a multi-layer perceptron) that learns as data streams in, rather than a static store that the agent reads and writes explicitly.
This is combined with the MIRAS framework, which provides a theoretical blueprint for sequence models that can maintain long-term memory by updating their core memory while actively running, without dedicated offline retraining.
The key idea: instead of compressing information into a static state, the architecture actively learns and updates its own parameters as data streams in. The model is not simply taking notes - it is understanding and synthesizing the entire story.
MIRAS defines a sequence model through four design choices:
- Memory architecture: the structure that stores information (a vector, matrix, or deep MLP)
- Attentional bias: the internal learning objective the model optimizes to determine what it prioritizes
- Retention gate: the memory regularizer that balances new learning against retaining past knowledge
- Memory algorithm: the optimization algorithm used to update the memory
Titans uses a "surprise" metric to determine what to remember: unexpected pieces of information trigger stronger memory encoding. Combined with momentum (considering both momentary surprise and the recent context flow) and adaptive weight decay (forgetting), the architecture can handle contexts larger than 2 million tokens.
The ACL 2026 Papers: MAGMA and GAM
Two papers at ACL 2026 proposed graph-based memory architectures for agents that both outperformed prior state-of-the-art systems.
MAGMA (Multi-Graph Agentic Memory Architecture) represents each memory item across orthogonal semantic, temporal, causal, and entity graphs. By decoupling memory representation from retrieval logic, MAGMA provides transparent reasoning paths and fine-grained control over retrieval. It formulates retrieval as policy-guided traversal over these relational views, enabling query-adaptive selection and structured context construction.
GAM (Hierarchical Graph-based Agentic Memory) addresses the fundamental tension between rapid context perception and stable knowledge retention. It uses a dual-phase approach: an episodic buffering phase that captures ongoing dialogue in a local event progression graph, and a semantic consolidation phase that integrates completed narrative units into a topic associative network only upon semantic shifts. This prevents memory contamination - a phenomenon where established nodes become structurally isolated and forgotten due to weak connectivity in continuous stream-based systems.
The Convergence
Three approaches - filesystem memory stores, neural memory modules, and hierarchical graph architectures - are converging on the same insight: memory is not a bolt-on feature. It is a first-class primitive that requires dedicated architecture, explicit versioning, and careful retrieval design.
At Orioverse, we use Anthropic's memory store pattern for per-entity facts that survive sessions, and we are watching the graph-based approaches for more complex relationship-heavy use cases. The tiered approach - episodic, semantic, procedural - maps naturally onto both the filesystem store model and the graph consolidation model.
Read the full Context Engineering series: orioverse.com/blog/what-is-context-engineering