Memory-Augmented Agents: A Survey of Production Memory Systems

A significant development in applied LLM systems is the shift from stateless interaction toward persistent, evolving memory. Base language models are, by construction, stateless across calls; agentic systems that require continuity must supply memory externally. This article surveys three memory architectures that have transitioned from research to production use, and the benchmarks by which such systems are evaluated.

The limits of retrieval-based memory

Retrieval-augmented generation (RAG) treats memory as an information-retrieval problem: documents are embedded, semantically similar chunks are retrieved, and the retrieved text is inserted into the model's context. This approach is effective for static knowledge bases but is a poor fit for state that must evolve, such as:

• user preferences inferred over multiple sessions;
• dialogue history spanning discontinuous interactions;
• outcomes and corrections accumulated from prior tasks;
• relationships among entities that change over time.

The distinction is between retrieval over a fixed corpus and memory as a mutable, temporally structured store. Recent systems address the latter through graph-structured, hierarchical, and temporally aware representations.

Three production architectures

Mem0: extraction into a memory store

Mem0 [1] extracts salient facts from interactions and maintains them as a queryable memory, with a graph variant that represents entities and their relations explicitly.

from mem0 import Memory

memory = Memory()
memory.add("User prefers Python over JavaScript", user_id="alice")
memory.add("User is building a trading bot", user_id="alice")

context = memory.search("What should I recommend for alice's project?")

The reported design goal is to reduce the token cost of carrying full history while preserving the facts that matter for future turns [1].

Letta (formerly MemGPT): memory management via context tiers

Letta descends from the MemGPT proposal [2], which frames long-context handling as an operating-systems problem: a finite context window is managed like main memory, with less-relevant content paged out to external storage and retrieved on demand.

from letta import Agent

agent = Agent(
    memory_human="User: senior engineer, prefers concise responses",
    memory_persona="Assistant: technical advisor for distributed systems",
)

response = agent.send_message("Continue our discussion on Kafka partitioning")

Zep: temporal knowledge graphs

Zep [3] organises memory as a temporal knowledge graph, associating facts with the intervals over which they hold and thereby supporting queries about how information changed over time.

from zep_cloud.client import Zep

client = Zep(api_key="...")
client.memory.add(session_id="project-x", messages=[...])

results = client.memory.search(
    session_id="project-x",
    text="project architecture decisions",
    search_scope="summary",
)

An architectural observation

A design consideration common to all three systems is that memory writes are themselves state transitions, and therefore warrant the same reliability guarantees as other steps in a workflow:

graph TB
    subgraph "Agent runtime"
        A[Agent] --> M[Memory layer]
        M --> |read| SEM[Semantic memory]
        M --> |read| EPI[Episodic memory]
        M --> |write| PROC[Procedural memory]
    end

    subgraph "Persistence"
        SEM --> VS[(Vector store)]
        EPI --> KG[(Knowledge graph)]
        PROC --> ES[(Event store)]
    end

If an agent derives several conclusions and the process fails before the corresponding memory writes are committed, the resulting store may be partially updated. Treating memory writes as transactional—committing all writes within a step or none—avoids this inconsistency, which is the same atomicity concern studied in transactional systems.

Evaluation

Evaluating memory systems requires benchmarks that test recall over long, discontinuous interactions rather than single-passage retrieval. The LoCoMo benchmark [4] evaluates very-long-term conversational memory in LLM agents and is widely used as a reference. Reported accuracies vary substantially with domain, query type, and configuration; published figures should be read as configuration-specific rather than as fixed rankings, and practitioners are advised to run domain-specific evaluations. Mem0's own evaluation is reported in its accompanying paper [1].

Discussion

Persistent memory is increasingly treated as a baseline capability for agentic systems rather than an enhancement. The three architectures surveyed here embody distinct hypotheses—fact extraction, context tiering, and temporal graphs—and the appropriate choice is task-dependent. A cross-cutting requirement, independent of the memory model, is that memory operations be integrated into the execution layer with well-defined consistency guarantees.

References

1. Chhikara, P. et al., "Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory," arXiv:2504.19413. https://arxiv.org/abs/2504.19413
2. Packer, C. et al., "MemGPT: Towards LLMs as Operating Systems," arXiv:2310.08560. https://arxiv.org/abs/2310.08560
3. Rasmussen, P. et al., "Zep: A Temporal Knowledge Graph Architecture for Agent Memory," arXiv:2501.13956. https://arxiv.org/abs/2501.13956
4. Maharana, A. et al., "Evaluating Very Long-Term Conversational Memory of LLM Agents" (LoCoMo), arXiv:2402.17753. https://arxiv.org/abs/2402.17753