The best memory tools for AI coding agents in 2026

How we compared them

We make one of the tools on this list, so read this with that in mind. To keep ourselves honest we held every entry to three rules. Each fact about another product comes from that product's own website, documentation or repository, checked on 29 September 2026, and each entry links its source. Each entry opens with what the tool is genuinely good at. And where we could not confirm something, we left it out.

Prices and GitHub star counts change monthly. Treat them as a snapshot and follow the links before you commit to anything.

The list is limited to tools a developer can connect to Claude Code, Cursor, Codex or a similar coding agent today, through a plugin, an MCP server, or files the agent already reads. General memory infrastructure for building chat products is covered only where it also ships a coding-agent integration.

The question that sorts them: where does the memory live?

Almost every product here uses the word memory, so the word does not help you choose. Where the memory is stored does. It decides who can read it, whether it survives a new laptop, and whether a teammate's agent benefits from what yours learned yesterday. The eleven options fall into four places.

1. Files in the repository, read by the agent at the start of a session: CLAUDE.md, AGENTS.md, Cursor rules. Shared through git, kept true by hand.
2. A local database on your machine, filled by a plugin that watches your sessions: claude-mem, agentmemory, Basic Memory in its local mode. Private and automatic, and it stays on that one computer.
3. A hosted memory service that extracts facts from conversations and returns the relevant ones: Mem0, Supermemory, Zep, Cognee's cloud. Reachable from anywhere, usually priced by volume.
4. A shared project record that agents and people read and write on purpose, with typed entries and a lifecycle: ByteRover's context tree and Stele sit closest to this.

Letta Code is the outlier: it is a whole coding agent with memory built in, so choosing it means choosing a different agent.

At a glance

What they cost

Pricing in this category comes in three shapes, and the shape matters more than the headline number. Local tools cost nothing beyond your own machine. Most hosted memory services meter usage: retrievals, credits, tokens processed, or episodes stored. A few charge a flat price per person. Metered pricing is cheap while you experiment. It gets harder to predict once every prompt from every agent triggers a memory search, because the bill grows with how much your agents work.

Two things stand out. For a solo developer who wants hosted, shared memory across machines and tools, Stele's $12 Pro plan is the lowest first paid tier on this list. And it is one of the few that does not charge by how often your agents look something up: reads and search are not metered on any plan, so an agent that checks memory before every change costs the same as one that never does. That matters, because checking before acting is the behaviour you want to encourage.

Pro is also sized so most people never hit its limits: unlimited private projects, 3,000 writes a month, and 50,000 stored entries. For scale, we build Stele with Stele, with agents working in it every day. Over three months our own project gathered about 1,300 tasks and 940 active facts, roughly 750 writes a month, a quarter of the Pro allowance. Editing an existing fact does not count as a write. How we build Stele with Stele has the full numbers.

For teams the arithmetic depends on size. Stele's Team plan is $20 per person with no limit on agents, so a team of five pays $100 a month. Zep's Flex plan is $125 a month for five MCP seats, and Mem0 puts graph memory behind its $249 Pro plan. A team whose usage fits inside Mem0's $19 Starter limits will pay less there. And open-source projects pay nothing on Stele: public projects are free and unlimited.

1. The memory already built into your agent

Genuinely good at: costing nothing, needing no account, and being reviewed in the same pull request as the code it describes. Before you install anything, know what you already have.

Claude Code reads CLAUDE.md files at several scopes: an organization-wide managed file, a project file committed to git, a personal file, and a git-ignored CLAUDE.local.md. Separately, its auto memory writes notes to a folder under ~/.claude/projects/. That folder is on by default and is, in Anthropic's words, machine-local and not shared across machines. Only the first 200 lines of its index load at the start of a session. Source.

Codex reads AGENTS.md files from your home folder and then from the repository root down to the working directory, up to 32 KiB combined by default. Its separate memories feature is off by default, and when on it stores notes locally per user. Source.

Cursor uses rules: project rules in .cursor/rules, user rules, team rules on its business plans, and AGENTS.md. Its documentation puts it plainly: language models do not retain memory between completions, and rules provide the persistent context. Source.

Where it stops: the committed files are shared, but only as well as someone keeps them. Nothing tells you when a line has stopped being true, and the whole file loads whether or not it is relevant. The automatic memories are the reverse: they update themselves, but each one stays inside the tool and the machine that wrote it. Switch from Claude Code to Codex for an afternoon and the second agent knows none of what the first one learned. We wrote about that failure in detail in why markdown rot breaks agent memory.

Choose it if you work alone, in one tool, and can keep one file honest. That covers many projects.

2. claude-mem

Genuinely good at: capturing everything without you doing anything. claude-mem installs hooks that record what happens in a session, compress it, and inject relevant history into the next one. With roughly 95,000 GitHub stars it is by far the most adopted project in this category.

It stores memory in local SQLite with full-text search, with optional Chroma vectors. It started with Claude Code and now also supports Cursor, Windsurf, OpenCode and Codex CLI. It is Apache-2.0. The project also sells a hosted tier, and its README notes that some integrations default to it; the two official pricing pages we found listed different monthly prices, so check before you sign up. Source.

Where it stops: it records what happened, which is different from what was decided. A compressed session log answers "what did the agent do on Tuesday" well and "what is the rule for database migrations here" less well. And in its local mode, it is one person's memory.

Choose it if you are a single developer who wants continuity across sessions with zero effort.

3. agentmemory

Genuinely good at: being one local memory that every agent on your machine shares. agentmemory runs a local server, ships a Claude Code plugin with a dozen hooks and a Codex plugin, and exposes more than fifty MCP tools for everything else. Search is BM25, with optional embeddings and a graph. Apache-2.0, around 29,000 stars. Source.

Where it stops: the sharing ends at your machine. That is a feature if privacy is the point and a limit if a teammate's agent should benefit from what yours learned.

Choose it if you switch between several agents on one computer and want them to stop contradicting each other.

4. Basic Memory

Genuinely good at: keeping memory in files you can open, read and edit. Basic Memory writes plain markdown, links notes with wikilinks into a knowledge graph, and indexes them locally in SQLite with hybrid full-text and vector search. Any MCP client can use it. Local use is free under AGPL-3.0; a cloud version with a shared Teams workspace costs $15 a month in its current beta pricing. Source.

Where it stops: it is a general notes system with an agent interface, so project concepts such as tasks, owners or decisions that replace earlier decisions are conventions you build yourself.

Choose it if you want an agent-readable second brain that stays human-readable and portable.

5. Mem0

Genuinely good at: being a mature, widely used memory layer. Mem0 is the most starred general memory library, at about 66,000 stars, and its core is Apache-2.0. When a new memory contradicts an old one, Mem0 decides whether to add, update or delete, which keeps the store from filling with duplicates.

Most of Mem0's users build it into their own AI products through its Python and TypeScript SDKs. For coding agents, it now publishes an official Claude Code plugin, with plugin folders for Codex and Cursor. The plugin keeps a personal memory and a shared project memory that everyone on the repository reads and writes. It needs a Mem0 Platform API key. Pricing starts with a free Hobby tier, then $19 a month for Starter; graph memory arrives with the $249 Pro plan. Mem0 retired its earlier OpenMemory MCP server in July 2026. Source, pricing.

Where it stops: memories are extracted from conversation, so what lands in the pool is whatever the extractor judged worth keeping. That works well for preferences and facts. It gives you less control over the shape of a decision and when it should stop applying.

Choose it if you already use Mem0 in a product, or you want automatic, team-shared recall with minimal setup.

6. Supermemory

Genuinely good at: fast, low-friction recall across many agents. Supermemory ships plugins for Claude Code, Cursor, Codex and OpenCode that search memory on each substantive prompt and give up after three seconds rather than stall the agent. Memories are organized by project. The plugins stopped requiring a paid plan in July 2026; the free tier includes $5 of credits and Pro is $19 a month. The engine is MIT-licensed. Source, pricing.

Where it stops: self-hosting is listed under the Scale and Enterprise plans, so the practical default is their cloud. Like Mem0, it stores what it extracts, with less structure around what kind of fact each memory is.

Choose it if you want hosted memory in several agents quickly and the credit pricing fits your volume.

7. Zep and Graphiti

Genuinely good at: time. Graphiti, Zep's open-source engine, is a temporal knowledge graph: every fact carries when it became true and when it stopped, so an old fact is marked invalid instead of silently deleted. For questions like "what did we believe in March" that is the most careful model on this list. Graphiti is Apache-2.0, around 31,000 stars, and runs on Neo4j, FalkorDB or Neptune. Source.

Zep is the hosted service built on it. It offers a Memory MCP server and a plugin for Claude Code, Codex and Cursor; that memory belongs to the signed-in user. The free tier includes 10,000 credits and one MCP seat; the Flex plan is $125 a month. Zep's own community edition is no longer supported, so self-hosting means running Graphiti yourself. Pricing.

Where it stops: Zep is built first for companies putting memory into their own products, and its pricing reflects that. For a small team's coding agents it can be more machinery than the job needs.

Choose it if facts in your domain change often and you need to reason about their history.

8. Cognee

Genuinely good at: turning a pile of documents and code into a queryable graph. Cognee combines a graph and a vector store, defaulting to embedded local databases so it runs with no servers, and it offers an MCP server plus Claude Code and Codex plugins. Apache-2.0, around 31,000 stars. Its cloud charges per million tokens processed after a free allowance. Source, pricing.

Where it stops: Cognee is a general memory and knowledge-graph platform. Using it as a coding agent's project memory is one configuration among many, which means more setup decisions are yours.

Choose it if your agents need to reason over a large body of existing documentation.

9. ByteRover

Genuinely good at: treating context like code. ByteRover's brv command curates a tree of context files and versions it with branches, commits, pushes and pulls, so a team can review changes to what agents know. It connects to more than twenty agents over MCP. The free tier syncs 100 context files; Pro is $15 a month billed yearly. It is source-available under the Elastic License 2.0, which is not an OSI open-source license. Source, pricing.

Where it stops: version control tells you who changed a context file and when. It does not by itself tell you which entries are still true.

Choose it if your team already thinks in pull requests and wants the same review loop for agent context.

10. Letta Code

Genuinely good at: memory as a first-class part of the agent. Letta, formerly MemGPT, lets the agent manage its own memory explicitly. Letta Code is a full coding agent built on it, with a git-backed memory filesystem the agent edits and a background process that consolidates what it learned. Apache-2.0, and self-hostable. Pricing has a free tier and a $20 Pro plan, though Letta's own estimate puts regular coding use at around $100 a month of usage. Pricing, docs.

Where it stops: the memory belongs to Letta's agent. If your team uses Claude Code, Cursor and Codex, Letta Code is a fourth agent to adopt, and its memory will not follow you back to the other three.

Choose it if you are willing to switch agents for a memory-first design.

11. Stele

This is ours, so apply the same scepticism you would to any vendor describing itself.

Genuinely good at: one project record that every agent and every teammate shares, whatever tool they use. Stele stores typed entries: decisions, lessons, risks, tasks, and the components they belong to, linked to each other. Claude Code, Cursor, Codex, GitHub Copilot, OpenCode and any other MCP client read it before they act and write back what they learned. Each fact has a lifecycle: it can be superseded by a newer decision, expire on a date, or retire when the task it describes closes, so an agent is not served yesterday's rule as today's. Tasks are claimed atomically, so two agents do not pick up the same work. People see the same record in a web app. The free plan covers unlimited public projects and one private project; Pro is $12 a month and Team is $20 per person, with reads never metered.

Where it stops: Stele is a hosted service and there is no self-hosted version today. It asks agents to write facts on purpose rather than capturing everything, which produces a cleaner record and costs a little effort per session. And it is young: it is in its first public version, used by a small number of teams.

Choose it if more than one agent or more than one person works on the same project, and you want what one of them learned to reach the others. For the longer argument, see switch agents, keep the project and a file versus a shared ledger.

Which one fits your situation

• One developer, one agent, one machine: start with the built-in files. Add claude-mem if you want sessions captured automatically.
• One developer, several agents: agentmemory keeps them consistent on one computer. A hosted option such as Supermemory or Stele also covers a second machine.
• A team that wants automatic recall: Mem0's shared project pool or Supermemory's project memory.
• A team that wants a reviewable record: ByteRover if you want it versioned like code, Stele if you want typed decisions and tasks with a lifecycle.
• Facts that change and history that matters: Graphiti or Zep.
• Human-readable notes first: Basic Memory.
• Willing to change agents: Letta Code.

How to tell whether memory is helping

Every tool on this list can produce a demo where memory helps. Fewer can show that it helps on your project. Three checks take an afternoon and tell you more than any benchmark on a vendor's site, including ours.

First, look at what the tool actually injects. Most have a log or a debug mode. Count how many injected memories were relevant to the task. If most are noise, the agent is paying tokens to read them and may act on the wrong one.

Second, change a fact and see what happens. Tell the agent that the project moved from one database to another, start a fresh session a day later, and ask about the database. A tool that serves the old fact next to the new one without saying which is current will eventually mislead an agent at the worst moment.

Third, switch tools. Do some work in Claude Code, then open the same repository in Cursor or Codex and ask what was done. This is the check that separates memory that belongs to a tool from memory that belongs to the project.

The useful question is whether what one agent learned reaches the next agent that needs it, in a form it can trust.

We wrote up how we tried to measure this properly, and how many ways there are to measure nothing, in how do you measure whether agent memory actually helps.

Frequently asked questions