Helm7

Best Agent Memory Frameworks in 2026, Compared

The Helm7 team · Published 14 November 2026 · Checked 16 November 2026 · 9 min read

agent memory: a sticky note with a list, a pen and a notebook on a desk
Photo by Ivan S on Pexels

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?

Agent memory options as described on each project's own site or repository, 16 November 2026
OptionWhat it isLicenceWhere data livesHosted version
Mem0Memory layer: add, extract and update, retrieveApache 2.0Self-hosted server defaults to Postgres with pgvector; library mode defaults to local QdrantYes, a hosted platform with an API key
ZepEnterprise context layer for agents, with governed context graphsNot stated on its homepageZep Cloud, with your own keys, or in your own cloudYes, free tier and enterprise plans
GraphitiFramework for temporal knowledge graphs, behind ZepApache 2.0Neo4j, FalkorDB or Amazon NeptuneVia Zep
LettaPlatform for stateful agents with learned memoryApache 2.0Self-hosted App Server, or Letta CloudYes
LangGraph and LangMemLong-term memory toolkit on LangGraph's storeNot stated on its pageAny store; Postgres recommended for productionStore is on by default in LangGraph Platform deployments
CogneeOpen-source memory platform with graph and vector stateApache 2.0Can run on one Postgres instance; Postgres graph store is a demo featureManaged cloud and BYOC
A table in your own PostgresRows, a vector column and your own codeNot applicableYour databaseWhatever 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.”
Letta, Repository description, github.com/letta-ai/letta

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?

A starting point for choosing, based on what each project says it is for
If you needLook first at
Chat memory working this week, with least codeMem0
Facts that change over time, with historyGraphiti, or Zep for the managed product
An agent platform where memory is built inLetta
Memory inside agents already built on LangGraphLangMem
A knowledge graph from documents and chatCognee
Structured memories next to your business dataA 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.

Sources

  1. Mem0 on GitHub
  2. Zep homepage
  3. Graphiti on GitHub
  4. Letta on GitHub
  5. LangMem documentation
  6. Cognee on GitHub

Run your entire app stack, end to end, from $12 a month.

App, Postgres, auth, storage, jobs and domains on one platform, planned and priced before anything changes.

More from the blog