Agent Memory Tools Compared: What Each One Stores, What It Costs, and Whether You Can Read It Yourself

Agent memory is whatever an AI agent can recall that was not in the current prompt: facts about you, what happened in earlier sessions, and the relations between what it learned. The tools that provide it differ less in accuracy, where every vendor claims the top benchmark, than in three things you can check: how the memory is stored, what a month costs, and whether you can open the store and see what is in it and what is missing. This page compares ten tools on those three.

Every price, licence and limit below comes from the vendor's own pricing page, documentation or GitHub repository, fetched on 24 October 2026. Where a vendor does not state something, the page says "not published" instead of guessing. The comparison ends with a choice by use case (coding agent, support bot, personal second brain, research assistant, multi-agent team) and with the question none of the vendor pages ask: whether you can read your agent's memory yourself.

What Is Agent Memory?

Agent memory is the information an AI agent keeps between calls to the language model. The model itself is stateless: once a response is returned, everything in the prompt is gone. Memory tools store three kinds of content and hand the relevant part back at the start of the next session: facts (your name, stack, preferences), episodes (what happened in earlier sessions) and relations (how those facts and episodes connect). What a tool stores decides what it can later answer.

The metaphor the field uses, in Letta's and LangChain's own writing, is that the context window is RAM and memory is disk. The context window holds what the model is working on right now and is cleared when the session ends or the window fills. Memory is what survives that: a file, a database, a graph, that the agent or a retrieval step consults and copies the useful part back into the window.

IBM's, Mem0's and LangChain's explainers sort memory into four types: working memory (the context window), semantic memory (facts and preferences), episodic memory (events) and procedural memory (rules and skills, often a Markdown file such as CLAUDE.md). Facts and episodes above are the semantic and episodic types; what the taxonomy leaves out is relations, the links between facts. Memory is not RAG either: RAG re-derives context from the same documents on every query, memory is the record that persists and changes per user or project (MCP vs RAG vs AI agents).

Native Claude and ChatGPT memory are the versions most people meet first. Both remember facts about you inside their own app, both let you review the list in a settings screen, and neither leaves the app. The tools below exist for everything those two do not cover: memory an agent writes itself, memory shared between Claude Code, Cursor and a script, and memory that stores relations rather than paragraphs.

Four Ways to Store Agent Memory

Flat files are the simplest store: a CLAUDE.md, a Markdown folder, or the memory.jsonl file the reference MCP memory server writes. The agent rereads the file at the start of each session, so the whole memory travels into the context window every time. You can open the file and edit it. What it cannot do is answer "what changed" or "what is missing", because a file has no structure beyond its line order, and it stops working once it is larger than the window.

A vector store keeps each memory as an embedding and returns the entries most similar to the current query. Mem0's core, Supermemory's search and LangMem's store work this way. It scales to millions of entries and answers "what did I say about X" well. It cannot answer "what changed since last month" unless the tool adds timestamps and invalidation on top, and the store itself is a list of vectors nobody can read.

A temporal graph stores facts as edges between entities, each with a validity window. When a fact changes, the old edge is marked invalid rather than deleted. Zep's Graphiti is the reference design; Cognee's graph layer is close. This answers "what changed" and "what was true in March" directly. Reading the store means running a graph database and knowing how to query it.

A knowledge graph with structure analysis stores the same relations and then measures the graph the LLM reads from: which concepts form clusters, which hold the structure together, and where two clusters never connect. That last measurement is the only way a memory can report what it is missing. InfraNodus works this way (the mechanics are in knowledge graphs for LLMs). The cost is that it is built for a person to read and for an agent to query by structure, not for thousands of retrievals a second.

The storage model also decides what re-enters the context window each turn, a cost no monthly price shows. A flat file is reread whole, so its token cost grows with its length. A vector store returns a fixed number of nearest entries. A graph returns the subgraph around the query. The 2026 Particula test measured this, tokens and latency per turn, for Mem0, Zep, Letta and Cognee. A seat or a credit buys retrieval; whether it retrieves the right things you can only tell by looking at the store.

The Comparison Table

The table places each tool by storage model and then answers the three checkable questions. Licence, hosting and prices are copied from the sources listed under the table; "not published" means the vendor does not state it on any official page we fetched. Prices are monthly list prices in the vendor's currency; GitHub star counts in the sections below are from the GitHub API on the same date.

As of 2026-10-24

Sources, one official page per tool:

1. Mem0: github.com/mem0ai/mem0, mem0.ai/pricing, docs.mem0.ai/open-source/features/graph-memory
2. Zep and Graphiti: github.com/getzep/graphiti, getzep.com/pricing, help.getzep.com/quickstart
3. Letta: github.com/letta-ai/letta-code, docs.letta.com/guides/agents/memory, docs.letta.com/letta-code/pricing
4. Cognee: github.com/topoteretes/cognee, cognee.ai/pricing, docs.cognee.ai
5. Supermemory: github.com/supermemoryai/supermemory, supermemory.ai/pricing, supermemory.ai/docs/concepts/graph-memory
6. LangMem: github.com/langchain-ai/langmem, langchain-ai.github.io/langmem
7. MCP memory server: github.com/modelcontextprotocol/servers/tree/main/src/memory
8. Native Claude memory: support.claude.com/en/articles/11817273
9. Native ChatGPT memory: help.openai.com/en/articles/8590148-memory-in-chatgpt
10. InfraNodus: infranodus.com/mcp/memory

On accuracy, since every vendor leads with it: Mem0 reports 94.4 on LongMemEval and 92.5 on LoCoMo; Zep reports 90.2 and 94.7 at 104 ms median latency; Cognee reports 0.79 on its BEAM benchmark at 100K tokens; Supermemory claims first place on LongMemEval, LoCoMo and ConvoMem. An independent LongMemEval run in 2025 scored Mem0 at 49.0 and Zep at 63.8. All of these are vendor numbers on vendor-chosen setups, which is why they are not a column in the table.

Mem0

Mem0 extracts facts and preferences from conversations and stores them at user, session and agent level without overwriting earlier ones. Retrieval combines a vector store, BM25 keyword search and, on the platform, an entity graph it calls Graph Memory. The library is Apache-2.0 (67,712 stars); the managed platform adds optimizations absent from the open source SDK.

Hobby is free with 10,000 add requests and 1,000 retrievals a month; Starter is $19, and graph features sit on Pro at $249. You read memories in the platform dashboard, or in the vector database you run when self-hosting. Nothing reports what the memory lacks. Mem0 fits when you need a memory API for many users with a Python or TypeScript SDK.

Zep and Graphiti

Zep stores memory as a temporal knowledge graph: entities, facts with validity windows, and the raw episodes behind them. A changed fact is marked invalid rather than deleted, so the graph can answer what was true on a given date. Graphiti is the open source engine (Apache-2.0, 32,169 stars) and runs on Neo4j 5.26, FalkorDB or Neptune. Zep itself publishes no licence or community edition.

Zep Cloud is free for 10,000 credits a month with one Context MCP seat; Flex is $125 for 50,000 credits. Graphiti is free to run. You can read the store if you run the graph database and query it. Pick Zep when fact history matters: a support agent that must know last quarter's plan.

Letta (formerly MemGPT)

Letta puts memory where the model can see it: memory blocks pinned in the context window that the agent edits itself, a vector archive for older material, and every message kept. Everything is Apache-2.0 (25,239 stars for letta, 3,696 for letta-code, which tracks skills and memory files in git), on Letta Cloud or your own letta server.

Free covers 3 agents and 5 MiB per memory repo with your own model keys; Pro is $20 a month for 20 agents and 50 MiB; API is $20 plus $0.10 per active agent. Self-hosting cost and MCP support are not published. The blocks are plain text you can read and edit. Letta fits an agent that should manage its own notes.

Cognee

Cognee turns documents, conversations and code into entities, relationships and chunks behind four operations: remember, recall, improve and forget. The store combines a knowledge graph, a vector index and a relational database; the defaults are SQLite, LanceDB and Ladybug, with Neo4j, Neptune and Memgraph optional. It is Apache-2.0 (32,702 stars) and self-hosting is free.

Cognee Cloud is free for 1M tokens in one workspace, then $1.00 per 1M tokens processed; Enterprise pricing is not published. It ships an MCP server and plugins for Claude Code, Codex and Cursor. Reading the store means opening the databases you run. Of the developer tools here it is the closest to a knowledge graph, so it fits a research assistant with many source documents.

Supermemory

Supermemory stores three kinds of memory with different lifetimes: facts persist, preferences strengthen with repetition, episodes decay. Facts are linked by Updates, Extends and Derives relations and searched with embeddings plus hybrid retrieval; the engine is not published. The code is MIT (31,369 stars). There is a hosted API and a "Supermemory local" Docker build on port 6767.

Free gives $5 of credits a month for one seat; Pro is $19 for $20 of credits and 3 seats. Memory counts per tier are not published. It connects through an MCP endpoint and plugins for Claude Code, Cursor and Codex, and you read memories through the API. Supermemory suits a personal assistant whose preferences should fade and strengthen over time.

LangMem

LangMem is a Python library for LangGraph builders. It extracts semantic memories (facts, in collections) and episodic memories from conversations and can optimise prompts from them. Memories are JSON documents in a LangGraph store namespace with an embedding index: in-memory for development, Postgres for production. There is no graph layer. The library is MIT and free; LangGraph Platform pricing is not published on the pages we fetched.

The last PyPI release is 0.0.30 from October 2025, so nothing has shipped in a year, and the repository has 1,722 stars. You can read the store with SQL, since it is rows of JSON. Choose LangMem only if you already run LangGraph and want memory in the same deployment.

The MCP Memory Server (Anthropic reference) and Other File-Based Servers

The reference memory server (@modelcontextprotocol/server-memory) stores a small knowledge graph of entities, observations and relations in a local memory.jsonl file. You start it with npx -y @modelcontextprotocol/server-memory and the client gets tools such as create_entities, read_graph and search_nodes. It is MIT, free, and runs one process per client, so each client gets its own file unless you share the path.

In most setups this is what mcp memory means: a file the model writes and reads back. You can open it in any editor. Nothing in it tells you what is missing, and search matches names, not meaning. For the same MCP interface over a graph that is shared between clients and measurable, see the InfraNodus server at /mcp/memory.

Native Claude and ChatGPT Memory

Claude remembers individual topics generated from your chats, kept per project, and you read and edit them in Settings > Memory. Memory is included on Free, Pro and Max and on by default; Team and Enterprise owners enable it, then each member opts in. Sensitive topics are excluded unless you opt in, and there is no published API to this memory. Claude Code is a separate case, with CLAUDE.md and auto-memory files in your repository, covered in Claude Code memory.

ChatGPT keeps an explicit list of saved memories, a broader "improved memory" summary and a reference to past chats. You see the saved list in Settings > Personalization > Memory; deleted saved memories are logged for up to 30 days. OpenAI publishes no price list and says availability varies by plan, region, platform and workspace; memory is off by default in Healthcare and Enterprise Regulated workspaces. Both native memories stop at the app: Cursor, n8n or a script of yours never sees them.

A Note on codebase-memory-mcp

Searching for memory servers, you will meet codebase-memory-mcp from DeusData (47,344 stars). It is not conversational memory. It indexes your code into a persistent local knowledge graph of symbols, classes, call graphs, HTTP routes and docs, kept in SQLite with full-text search and parsed by one binary with 162 tree-sitter grammars. It is MIT, free, local only, and configures 45 clients including Claude Code, Codex, Cursor and VS Code. File it as a code-structure graph that sits next to any memory tool above, not as a replacement for one.

An Obsidian Vault as Memory

A Markdown vault is memory you own completely: every note is a file, readable by definition, versioned with git, and Claude Code or any MCP client that can read files can use it. What a vault lacks is retrieval. Until you add a layer, the agent either reads everything or searches by filename, and nothing shows which topics the vault covers and which it skips. The InfraNodus Obsidian Graph View Plugin adds the structure view, and the MCP route is in Obsidian MCP.

InfraNodus: Memory as a Knowledge Graph You Can See

The same three checks, applied to InfraNodus. Storage: memory is a knowledge graph in your account, in three layers that follow the AI memory stack methodology: content graphs built from your files, insight memory the model proposes and you approve (memory_add_relations, memory_get_relations), and agent learnings saved per project (add_project_learnings, get_project_learnings). The graph records which concepts co-occur and how they cluster, so each layer is queried by structure with retrieve_from_knowledge_base instead of being reread.

Cost and hosting: InfraNodus is hosted only, with no self-hosted or open source edition; the MCP server is free to try with rate limits, and sustained use needs a plan from €19 a month. If your agent serves thousands of users with retrieval on every turn, Mem0, Zep or Cognee are built for that and InfraNodus is not. It is not a drop-in SDK either: you connect it through the InfraNodus MCP server from Claude Desktop, Claude Code, Cursor, ChatGPT or n8n.

Readability is where it differs. Every layer opens as a graph in the web app and in the Obsidian plugin: you see the topical clusters of what your agents learned, click a cluster to inspect the statements behind it, and delete or rewrite a statement the model got wrong. And it is the one tool in the table that reports its own content gaps: generate_content_gaps names the clusters that never connect, and you can ask the AI Insights panel a follow-up from that selection to decide what to record next.

Start Keeping Learnings for a Project

https://mcp.infranodus.com

https://mcp.infranodus.com

claude mcp add infranodus -s user --transport http https://mcp.infranodus.com/mcp

{
  "mcpServers": {
    "infranodus": {
      "url": "https://mcp.infranodus.com"
    }
  }
}

codex mcp add infranodus --url https://mcp.infranodus.com
codex mcp login infranodus

{
  "mcpServers": {
    "infranodus": {
      "command": "npx",
      "args": ["-y", "infranodus-mcp-server"],
      "env": {
        "INFRANODUS_API_KEY": "your-api-key"
      }
    }
  }
}

/plugin marketplace add infranodus/skills
/plugin install project-learnings@infranodus-skills

npx skills add infranodus/skills --skill project-learnings -g -a claude-code -y

$skill-installer install the project-learnings skill from https://github.com/infranodus/skills

npx skills add infranodus/skills --skill project-learnings -g -a codex -y

npx skills add infranodus/skills --skill project-learnings -g

Start keeping learnings for this project. Before we begin, check what earlier sessions learned here with get_project_learnings; when we finish, propose the new learnings and let me review the batch before you save it.

Which Agent Memory Tool Should You Use?

For a coding agent, start with what you have: CLAUDE.md and auto-memory for the rules, codebase-memory-mcp if you want the call graph. Add the InfraNodus Project Learnings skill when the same agents keep rediscovering the same traps, so the lessons land in a graph you can audit and that Claude Code, Cursor and the web app all read. Letta Code is the alternative if you prefer the agent to manage its own memory files.

For a support bot or any product with many end users, pick Mem0 or Zep. Mem0 gives per-user memory through an SDK with a free tier of 10,000 adds; Zep gives fact history, so the bot knows what changed in a customer's account. Both are built for retrieval on every turn, which a production bot needs. If the bot handles customer data, check each vendor's compliance page (SOC 2, HIPAA, a BAA) yourself; this page did not verify those claims.

For a personal second brain, keep notes in an Obsidian vault or a Markdown folder, add Supermemory or the reference MCP memory server if the agent should remember preferences, and add InfraNodus when you want to see what your notes and your agent's memory cover and where they are thin. The LLM Wiki skill comes after that, when recurring themes deserve maintained pages.

For a research assistant that reads many documents: Cognee if you are a developer and want the graph in your own database, InfraNodus if you want to read the graph yourself and work the gaps between sources. For a multi-agent team, choose the store all agents reach through one protocol: Zep's Context MCP seats, Cognee's MCP server, or the InfraNodus MCP server, which every connected client reads and writes.

What Nobody Measures: Can You Read Your Agent's Memory?

The comparisons that rank for "mem0 vs zep" sort tools by benchmark accuracy, and the independent LongMemEval run above shows those numbers do not travel between setups. What does travel is what the store looks like after a month. With flat files, it is a file you can read until it is too long to read. With a vector store, it is a dashboard of entries, or nothing. With a graph database, it is a query to write. With a knowledge graph with structure analysis, it is a picture.

A learnings graph after a month of Claude Code sessions shows a cluster around deployment, one around the test suite, one around an awkward module, and a gap: nothing connects the deployment lessons to the test lessons, which is where the last two incidents happened. Click the deployment cluster and the statements the agent wrote appear underneath. Remove the top nodes and the smaller insight clusters, lessons recorded once and never repeated, come forward.

That is the difference between a memory you trust because the benchmark says so and a memory you trust because you looked. After a month the test is whether the agent's answers got better, and only a readable store lets you trace which learnings did that. Then run the same loop as on any text in InfraNodus: inspect the statements behind a cluster, delete what is wrong, ask the AI Insights panel what would bridge the gap, and save it to Project Notes or back into the learnings graph.

Get Started

Frequently Asked Questions

Give Your Agent a Memory It Can Show You

Connect the InfraNodus MCP server to Claude Desktop, Claude Code or Cursor, run /infranodus in a project, and the first learnings graph appears after one session: the topics your agent recorded, the concepts that connect them, and the gaps between them. A free InfraNodus account covers the web app and a first run of the MCP server; sustained MCP use is on the plans from €19 a month.