Best Agent Memory Frameworks in 2026, Compared
The Helm7 team · Published 14 November 2026 · Checked 16 November 2026 · 9 min read

Agent memory frameworks promise that your assistant will remember what matters. Several of them changed direction in 2026, so a list from last year may point you at the wrong thing. We read each project's own site or repository this week and compared what they say they are today. There is no single winner, and one of the options is simply a table in your own Postgres.
In short
- Agent memory covers three jobs: extraction, storage and recall, and the agent runtime. Check which one a framework actually does.
- Mem0 is the quickest route for chat memory. Letta is a full agent platform. Graphiti and Zep focus on time-aware graphs. Cognee targets graph memory for teams. LangMem fits LangGraph agents.
- Zep's homepage now describes an enterprise context layer, with agent memory as one of four use cases. Letta's repository says its current code lives in letta-code and its V1 server is retired.
- Postgres appears as a storage option across the board. That makes a plain table a serious choice when your memories are structured and sit beside your other data.
- Benchmark scores quoted by these projects are their own. Test on your own conversations.
What counts as an agent memory framework?
Three different jobs hide behind the phrase agent memory. The first is extraction: reading a conversation and deciding what is worth keeping. The second is storage and recall: holding facts and finding the right ones later. The third is the runtime: an agent loop that decides when to read and write its own memory.
Frameworks cover different slices of that. Some do all three. Some do only the middle. A few stores do only storage and leave the rest to you. Comparing them on one scale is unfair unless you know which job you are hiring them for, so each section below says what the project actually is.
A note on method. We opened each project's own page, and we state only what that page says. Where a page was silent, we say so. Stars and benchmark scores are the projects' own figures and we did not run them.
How do the six options compare at a glance?
| Option | What it is | Licence | Where data lives | Hosted version |
|---|---|---|---|---|
| Mem0 | Memory layer: add, extract and update, retrieve | Apache 2.0 | Self-hosted server defaults to Postgres with pgvector; library mode defaults to local Qdrant | Yes, a hosted platform with an API key |
| Zep | Enterprise context layer for agents, with governed context graphs | Not stated on its homepage | Zep Cloud, with your own keys, or in your own cloud | Yes, free tier and enterprise plans |
| Graphiti | Framework for temporal knowledge graphs, behind Zep | Apache 2.0 | Neo4j, FalkorDB or Amazon Neptune | Via Zep |
| Letta | Platform for stateful agents with learned memory | Apache 2.0 | Self-hosted App Server, or Letta Cloud | Yes |
| LangGraph and LangMem | Long-term memory toolkit on LangGraph's store | Not stated on its page | Any store; Postgres recommended for production | Store is on by default in LangGraph Platform deployments |
| Cognee | Open-source memory platform with graph and vector state | Apache 2.0 | Can run on one Postgres instance; Postgres graph store is a demo feature | Managed cloud and BYOC |
| A table in your own Postgres | Rows, a vector column and your own code | Not applicable | Your database | Whatever hosts your database |
Notice how often Postgres appears. Memory frameworks are converging on it as one of the places data can live, and a few of them default to it. That changes the question from where do I store memory to who owns the logic on top.
Mem0: the default pick for chat memory
Mem0 describes itself as a memory layer for AI agents. You add data, it extracts and updates memories, and you retrieve relevant ones later. The repository is Apache 2.0 licensed with about 69,000 stars, and the README reports a new memory algorithm from April 2026 with scores of 92.5 on LoCoMo and 94.4 on LongMemEval. Those are Mem0's own numbers, from its managed platform, and the README says open-source users should expect directionally similar but not identical results.
Choose it when your agent talks to people and you want agent memory working quickly. The cost is another service, or another Docker stack,. We wrote a longer Mem0 review against plain Postgres tables if this is your shortlist's front-runner.
Zep and Graphiti: temporal graphs, and a product that moved
Graphiti is the open-source piece. Its README calls it a framework for building temporal knowledge graphs for AI agents. Facts have validity windows, and superseded facts are invalidated rather than deleted, so you can ask what was true on a given date. It runs on Neo4j, FalkorDB or Amazon Neptune. The README says plainly that its reference MCP and REST servers are not production deployments and have no authentication, and it points to Zep as the production option.
Zep is where the direction has shifted. Its homepage now describes an enterprise context layer for agents, providing governed access to company knowledge and skills built from agent tasks. The main features are a Context Lake that unifies business data into context graphs, and Agent Skills, built from agent run traces. Agent memory is listed as one of four use cases, alongside a company brain, customer context and vertical agents. We could not tell from the page what changed from earlier versions, so read that as how it presents itself today, not as a verdict on the older product.
Pick Graphiti if time-aware agent memory matters and you are happy to run a graph database. Pick Zep if you want the managed product and its governance features. If you only wanted a simple memory store, check that the product still matches what you need before you start.
Letta: the agent runtime where memory is the point
Letta, formerly MemGPT, is an Apache 2.0 platform for stateful agents. Its own description is below. It is a runtime, not a library you bolt on. Your agents live inside it.
“Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.”
Two status notes matter. The repository says current source code lives in a separate letta-code repository, and that its archive branch holds the retired Letta V1 API server. If you built against the old server API, that is a migration. You can self-host the runtime with the Letta App Server, or use Letta Cloud.
Choose it if you want an agent platform and agent memory handled by one thing. Skip it if you already have an agent loop you like and only want a memory store.
LangGraph and LangMem: memory inside the framework you may already use
LangMem's page says it helps agents learn and adapt from their interactions over time. It offers ways to extract information from conversations, refine prompts and keep knowledge across sessions, and it names semantic and episodic memory in its guides. It works with any storage system through functional primitives, and it integrates natively with LangGraph's long-term memory store.
The page's examples use an in-memory store, which loses data on restart. For production it recommends a database-backed one, such as AsyncPostgresStore. So in practice this route also ends in a Postgres table, with LangMem's extraction on top.
Choose it if your agents already run on LangGraph. The integration is the draw. We could not confirm a release status from the page, so check the repository for activity before you commit.
Cognee: graph memory, now pointed at teams
Cognee's repository calls it the open-source AI memory platform for agents, under Apache 2.0. Its homepage headline is memory for agents, teams and people, and it lists three focus areas: a company brain for teams, an SDK for agent builders and tools for generating domain-specific ontologies. It connects sources such as Slack, GitHub and Linear.
The README says that since Cognee 1.0 you can run the whole memory layer on a single Postgres instance, with pgvector for vectors and Postgres for relational metadata. It also says that using Postgres as a graph store is a demo feature, and that a production-ready version is a licensed product. The site's benchmark and traction figures are self-reported.
Choose it if you want graph-based agent memory built from documents and chat, and you are comfortable with an LLM-driven pipeline. Note the Postgres graph limitation before you plan to stay on one database.
Is a table in your own Postgres a framework?
It is the agent memory option nobody sells you, which is why it is missing from most lists. A memory is a row with text, an owner, a vector and maybe a validity window. A small amount of code handles writing and recall. You get joins to your own data, transactions, backups and row level security from day one.
You give up the extraction logic and the research behind it. If your memories are structured facts, such as a customer's preferences, decisions on a ticket or notes on an account, that is a fair trade. If you need an agent to distil long free-form conversations into durable facts, it is not.
On Helm7 this is a template on the databases page: it creates a memory.items table in your own database, makes titles and bodies searchable by meaning and keyword, and turns on relationships so a single search can start semantically and walk two hops. Your agent writes the memories. We sell this route, so weigh our view accordingly. For the storage trade-offs behind it, see which database for LLM memory.
How should you choose?
| If you need | Look first at |
|---|---|
| Chat memory working this week, with least code | Mem0 |
| Facts that change over time, with history | Graphiti, or Zep for the managed product |
| An agent platform where memory is built in | Letta |
| Memory inside agents already built on LangGraph | LangMem |
| A knowledge graph from documents and chat | Cognee |
| Structured memories next to your business data | A table in your own Postgres |
Before you commit to any agent memory tool, spend an afternoon with real conversations from your own product. Benchmarks on public datasets will not tell you how any of these behaves on your data. And check the project's page again on the day you decide. This category moved faster in 2026 than most.
Common questions
What is the best agent memory framework?
It depends on the job. Mem0 suits quick chat memory, Letta suits a full agent runtime, Graphiti suits time-aware knowledge graphs, and LangMem suits LangGraph users. For structured facts next to your own data, a table in Postgres is often enough.
Is Zep still a memory product?
Its homepage describes an enterprise context layer for agents, and lists agent memory as one of four use cases. The open-source Graphiti framework behind it is a temporal knowledge graph library under Apache 2.0.
Can agent memory live in Postgres?
Yes. Mem0's self-hosted server defaults to Postgres with pgvector, LangMem recommends a Postgres-backed store for production, and Cognee can run its memory layer on one Postgres instance. Cognee's Postgres graph store is still a demo feature.
What is the difference between short-term and long-term agent memory?
Short-term memory holds the current conversation. Long-term memory keeps facts across conversations, such as preferences and past decisions, so a new session can start with that context.