Agent memory frameworks provide persistent, queryable memory infrastructure for AI agents, enabling them to remember user preferences, track conversation history, and build knowledge over time. Unlike simple conversation buffers, these frameworks offer structured storage, semantic retrieval, and temporal reasoning that transform stateless LLM calls into stateful agent systems.

LLMs are inherently stateless — each API call starts fresh with no knowledge of previous interactions. Memory frameworks solve this by:

• Personalizing responses based on accumulated user preferences and history
• Maintaining context across sessions, days, and weeks
• Tracking how facts evolve over time (temporal reasoning)
• Sharing knowledge across multiple agents in orchestrated systems
• Reducing token costs by storing and retrieving only relevant context

Mem0 uses a dual-store architecture combining vector databases (Qdrant, Chroma, Milvus, pgvector) with knowledge graphs. An extraction pipeline converts conversations into atomic memory facts scoped to users, sessions, or agents.

Zep implements a temporal knowledge graph that tracks how facts change over time. It scores 63.8% on the LongMemEval benchmark with sub-200ms retrieval latency. Offers Python, TypeScript, and Go SDKs with SOC2 Type 2 and HIPAA compliance.

Letta uses a three-tier memory hierarchy inspired by operating systems:

• Core memory — Always in the LLM context window (like RAM)
• Recall memory — Searchable conversation history (like disk cache)
• Archival memory — Long-term queryable storage (like cold storage)

Agents actively self-edit their memory blocks, deciding what stays in context versus what gets archived.

LangMem uses a flat key-value plus vector architecture with MIT licensing and deep LangGraph integration. Unique features include prompt optimization from conversation data and a background memory manager for automatic extraction.

from mem0 import Memory
 
# Initialize memory with user scoping
memory = Memory()
 
def memory_agent(user_id: str, message: str, llm_client):
    # Retrieve relevant memories for this user
    relevant = memory.search(query=message, user_id=user_id, limit=5)
    memory_context = "
".join(m["memory"] for m in relevant)
 
    # Generate response with memory context
    response = llm_client.chat(
        messages=[
            {"role": "system", "content": f"User memories:
{memory_context}"},
            {"role": "user", "content": message}
        ]
    )
 
    # Store new memories from this interaction
    memory.add(
        messages=[
            {"role": "user", "content": message},
            {"role": "assistant", "content": response}
        ],
        user_id=user_id
    )
 
    return response
 
# Memories persist across sessions
memory_agent("user_123", "I prefer Python over JavaScript")
# Later session...
memory_agent("user_123", "What language should I use for this project?")
# Agent recalls the user's Python preference

• Choose Mem0 when you need battle-tested, widely-adopted memory with flexible backend options and multi-agent knowledge sharing
• Choose Zep when temporal reasoning is critical — tracking how facts evolve over time — and you need enterprise compliance
• Choose Letta when agents need active control over their own memory management and dynamic context curation
• Choose LangMem when you are committed to the LangGraph ecosystem and want cost-free, fully-owned memory infrastructure
• Choose Motorhead for lightweight prototyping where a simple REST API with Redis-backed sessions is sufficient

The LongMemEval benchmark measures long-term memory capabilities:

• Cognee: 81.6% (highest score, vector + knowledge graph with built-in RAG)
• Zep/Graphiti: 63.8% (best temporal reasoning)
• Mem0 and Letta: Strong but lack published benchmark scores

• Vectorize - Best AI Agent Memory Systems
• Mem0 Documentation
• Zep Documentation
• Letta (MemGPT) Documentation

• Retrieval Augmented Generation — RAG patterns that memory frameworks build on
• Embeddings — Embedding models powering semantic memory retrieval
• Knowledge Graphs — Graph-based knowledge storage
• Agent Orchestration — Shared memory in multi-agent systems