AI agent memory frameworks store what an agent learns across turns and sessions, then return the relevant parts on the next request. The seven options below fall into three groups: add-on memory layers, agent runtimes with built-in memory, and managed cloud memory services.
The right choice depends on whether facts change over time, where data must live, and who should decide what gets remembered. This comparison uses each vendor's current documentation, read on 3 November 2026.
How We Evaluated
We did not run our own benchmark. Each option was reviewed against the same six criteria, using official documentation only:
• Memory model: extracted facts, knowledge graph, editable memory blocks or checkpointed state
• Who decides what to store: the framework's pipeline, the agent itself, or your code
• Hosting: open source and self-hosted, managed cloud, or both
• Time awareness: whether old facts are versioned or overwritten
• Integration: fit with common agent frameworks and clouds
• Limits: what the documentation says, or does not say, about scale and governance
The Seven Options at a Glance
| Option | Memory model | Hosting | Best fit |
|---|---|---|---|
| Mem0 | Extracted facts with vector search | Open source or managed platform | Adding user memory to an existing agent |
| Zep with Graphiti | Temporal knowledge graph | Managed service; Graphiti engine is open source | Facts that change over time |
| Letta | Agent-edited memory blocks plus archival store | Open source server or Letta Cloud | Long-running stateful agents |
| LangGraph memory | Checkpointed thread state plus a long-term store | Your infrastructure or LangGraph platform | Teams already building on LangGraph |
| LlamaIndex Memory | Short-term buffer plus pluggable long-term blocks | Your infrastructure | LlamaIndex agent workflows |
| Amazon Bedrock AgentCore Memory | Managed short-term and long-term memory | AWS managed | Agents running on AWS |
| Vertex AI Memory Bank | Managed long-term memories per user scope | Google Cloud managed | Agents on Vertex AI Agent Engine |
1. Mem0
Mem0 is a memory layer you place beside an agent. You send it conversation turns; it extracts facts and preferences and returns relevant ones on later requests.
• Strength: quick to add to an existing app; open-source library and hosted platform
• Watch for: extraction decides what is kept, so test what it misses and what it wrongly stores
• Fits: personalization, assistant recall and support history
2. Zep with Graphiti
Zep builds a context graph from chats and business data. Its engine, Graphiti, is an open-source temporal knowledge graph where facts carry validity windows.
• Strength: can answer what was true at a given time, not only what is true now
• Watch for: graph construction adds ingestion cost and a graph database to operate if you self-host Graphiti
• Fits: account histories, changing customer states and multi-hop questions
3. Letta
Letta comes from the MemGPT research line. Agents hold labeled memory blocks in context and use tools to edit them, with a searchable archival store for older material.
• Strength: every memory edit is an inspectable agent action
• Watch for: memory decisions use model calls, which add latency and cost
• Fits: long-lived agents where memory is part of the agent's behavior
4. LangGraph Memory
LangGraph separates short-term memory, saved as thread checkpoints, from long-term memory kept in a store you namespace by user or organization. LangMem adds extraction utilities.
• Strength: you control the schema, storage and retrieval logic
• Watch for: you also own extraction quality, retention and deletion
• Fits: teams already using LangGraph who want memory in the same codebase
5. LlamaIndex Memory
LlamaIndex Memory combines a short-term chat buffer with long-term memory blocks, such as static facts, extracted facts and vector-retrieved history.
• Strength: composable blocks with token limits you can tune
• Watch for: persistence and multi-tenant isolation are your responsibility
• Fits: document-heavy agents already built on LlamaIndex
6. Amazon Bedrock AgentCore Memory
AgentCore Memory is a managed AWS service with short-term event storage and long-term memory produced by configurable strategies, such as summaries, preferences and facts.
• Strength: managed storage and IAM-based access inside AWS
• Watch for: ties memory to AWS; check regional availability and quotas in current docs
• Fits: enterprises standardizing agents on AWS
7. Vertex AI Memory Bank
Memory Bank is part of Vertex AI Agent Engine. It generates and stores long-term memories scoped to a user and retrieves them for later sessions.
• Strength: managed generation and consolidation of memories
• Watch for: ties memory to Google Cloud; review feature status and pricing pages before committing
• Fits: agents built on Google Cloud
Our own product. LuMay builds custom AI agents and includes memory and state design in that work. We are not ranked in this list. Our AI agent development page describes the service.
How to Choose: A Short Decision Path
Worked Example: Choosing Memory for a Support Agent
Illustrative example. A B2B software company wants its support agent to remember each customer's product tier, open issues and contact preferences.
• Changing facts: tier and open issues change weekly, so stale facts are a real risk
• Data rules: customer data must stay in the company's AWS account
• Shortlist: AgentCore Memory for managed storage, or self-hosted Graphiti on a graph database
• Decision test: run 50 real support threads through both and score recall of current facts and rejection of outdated ones
The team should also confirm that CRM remains the system of record. Memory is a cache of context, not the source of truth.
Governance Checklist for Agent Memory
• Memory is scoped per user, account or tenant, with no cross-tenant retrieval
• Personal data in memory follows the same retention and deletion rules as source systems
• Users or admins can view and delete stored memories
• Memory writes are logged with source turn and timestamp
• Sensitive fields are excluded or redacted before storage; see our guide to PII redaction for LLM applications
• Memory recall is part of your evaluation suite, as in AI agent testing frameworks for CI/CD
Limitations of This Comparison
Features and pricing change often, and several managed services add capabilities monthly. We did not test accuracy or latency. Third-party benchmarks disagree, so run your own test on your own conversations before choosing.
Next Step
If you are planning an agent that must remember customers, cases or tasks across sessions, LuMay's AI agent development team can help design memory, state and the governance around them.
