The Best Memory Solutions for Your Claude AI Agents in 2026

Your agent worked out how the billing module hangs together, hit the migration trap that eats a weekend, and made a call about why you're not using an ORM there.

Then the session ended and all of it went in the bin.

Tomorrow it reads the same twelve files, reaches the same conclusions, and charges you the same tokens for the privilege. Everyone running coding agents hits this within a week. What follows is the honest map of what you can do about it, what each option actually costs, and where each one falls over.

First, two different problems

Most memory advice is confusing because it mixes up two things that need different tools.

Instructions are what you already know and want the agent to follow. Your conventions, your commands, your architecture rules. You write these. They're stable.

Learned knowledge is what the agent works out while doing the job. Why a decision got made, which module is a minefield, what broke last time. Nobody writes these down, which is exactly why they get lost.

A CLAUDE.md is brilliant at the first and useless at the second. Most of the tools below exist because of the second.

The free option you already have: CLAUDE.md and AGENTS.md

Start here, because a lot of people skip it and buy a vector database instead.

CLAUDE.md is a Markdown file Claude Code reads at the start of every session. It concatenates up the directory tree, supports @ imports up to four hops deep, and pairs with .claude/rules/ for glob-scoped rules. AGENTS.md is the open equivalent, now used across 60,000+ repos and 20+ tools. Worth knowing: Claude Code doesn't read AGENTS.md natively. Anthropic's bridge is a CLAUDE.md whose first line is @AGENTS.md.

Claude Code also ships its own auto memory, separate from CLAUDE.md: a machine-local MEMORY.md plus topic files, with the first 200 lines or 25KB loaded per session.

Where it wins: free, git-reviewable, human-editable, zero infrastructure, portable.

Where it breaks: it eats context on every single session, it doesn't scale past a few hundred facts, and it goes stale silently. A stale MEMORY.md is worse than none, because the agent starts confidently wrong instead of admitting ignorance. Context bloat, not retrieval quality, is the most-reported practical problem with this approach. Anthropic now ships /doctor trim proposals and hard-errors when the file blows past its read limit, which tells you how common it got.

If you're not already getting this file right, fix that before anything else. Our CLAUDE.md guide covers the patterns that hold up.

Managed memory layers: mem0, Letta, Zep

This is the category that markets itself hardest.

mem0 (Apache-2.0, ~61k stars) is a memory layer that runs an LLM extraction pass on write and stores the result in a hybrid semantic-plus-keyword index. Hosted MCP endpoint, plus a Claude Code plugin with lifecycle hooks. Free tier at 10k operations a month, then $19, then $249.

Letta (formerly MemGPT, Apache-2.0, ~24k stars) takes a different angle: agents edit their own memory through tool calls, in an OS-style hierarchy of in-context memory blocks, recall storage, and an archival vector store. It's an MCP client, not a server. Free for three agents, $20/mo above that.

Zep is the commercial product built on Graphiti, a temporal knowledge graph engine (Apache-2.0, ~29k stars). Graphiti is the genuinely interesting bit: it's bi-temporal, recording both when something happened and when it was ingested, and closes validity windows when facts contradict rather than deleting them. It's the only approach here that answers "what did we believe in March?" Zep itself is not open source, and the Community Edition was deprecated in April 2025.

One thing to ignore: the "state of the art in agent memory" benchmark claims. The mem0-versus-Zep dispute over LoCoMo scores is unresolved and every benchmark in it is vendor-run. Zep's 84% included an adversarial category in the numerator but not the denominator, mem0's rerun landed at 58.44%, Zep countered with 75.14%. Pick on architecture and cost, not on a number in a launch post.

Where they win: scale, retrieval across huge histories, zero ops if you go hosted.

Where they break: silent retrieval misses, an LLM call on every write, imprecise deletion (a real GDPR problem), and your code leaving your machine. There's also a documented pattern of open-source-then-commercial drift: Zep CE deprecated, mem0's OpenMemory component being sunset, Supermemory gating supported self-hosting. Read the licence before you build on it.

Markdown-native MCP servers: basic-memory and friends

basic-memory (AGPL-3.0) is an MCP server that builds a semantic graph out of plain Markdown. Files stay the source of truth, SQLite is just an index, and entities and relations come from WikiLinks. Local is free, cloud is $15/mo.

This is the shape a lot of people actually want: files you can read and diff, with a real retrieval layer over them.

The Obsidian route

You'll see a lot of "build an AI second brain with Obsidian and Claude Code" content. It's a real workflow, so here's what's actually true.

Obsidian is a free local Markdown app with a graph view and nearly 6,000 community plugins. It shipped an official CLI in early 2026 whose own docs talk about giving agentic tools the ability to interact with your vault. Its CEO publishes a set of Agent Skills for Obsidian formats.

What it does not have: any official AI feature, and any official MCP server. Agent access means picking community components. The Local REST API plugin now bundles its own MCP server, and there are several third-party Obsidian MCP servers. GitHub returns over 1,800 repos for "obsidian mcp", which tells you both that it works and that nobody agrees on how.

Two more things worth knowing before you plan a team around it. Sharing a vault runs through Obsidian Sync, at $4 to $8 per user per month, capped at 20 collaborators, with every collaborator needing their own paid seat. And Obsidian's own documentation says it does not yet support collaborative live editing; multiplayer is listed as planned on the roadmap. Community plugins like Relay add it.

Also, clear up one outdated fact while you're here: Obsidian's commercial licence became optional in February 2025. The app is free for work. Plenty of comparison posts still claim otherwise.

We wrote up the full breakdown in AgentsRoom vs Obsidian, including the rows where Obsidian is straightforwardly the better tool.

Memory built into the IDE: AgentsRoom Project Memory

Every option above asks you to assemble something: a service to sign up for, a server to run, a plugin to maintain, a file to keep current by hand.

Project Memory in AgentsRoom takes the opposite approach. The memory lives in the IDE where your agents already run, and the agents write it themselves.

Three MCP tools ship with it. memory_list and memory_get for reading, which agents are instructed to call before they start crawling a codebase. memory_save for writing, with no confirmation step, so saving is a normal working gesture rather than a thing you have to remember to ask for. Notes land in five folders that create themselves on first use: architecture, decisions, conventions, pitfalls, features. Saving under an existing name updates that note in place, so the memory deepens instead of sprawling.

The part that matters most for teams: the memory is keyed to the project id committed in your repo, not to your user account. Your teammate clones, opens the project, and their agents inherit everything yours learned. No invite, no export, no per-seat subscription. It's included, with no note limit.

Notes link to each other with [[wiki-links]], and those links are the edges of a graph view where node brightness tracks how recently a note was updated. Knowledge going stale visibly fades on a sixty-day horizon, which is a cheap fix for the stale-memory failure mode that bites the CLAUDE.md approach.

Capture happens at three moments: opportunistically after any significant result, at the end of every turn for agents with "Always memorize" on, and through a prompt when you close an agent that still has a live session. That last one matters more than it sounds. The moment knowledge normally evaporates is the moment it gets written down.

Two honest limits. It's desktop-only today, with no mobile app. And agent reads and writes go to the server, so agents need connectivity, even though the desktop UI keeps showing your notes from a local cache when you're offline.

The pattern nobody says out loud

Look at where the industry actually landed and something clicks.

Anthropic's memory tool is a filesystem interface. Claude Code's auto memory is a directory of Markdown. Letta's memory blocks are editable strings. basic-memory is literally Markdown on disk. Meanwhile vector and graph stores dominate the multi-user application layer, where you're serving memory to thousands of end users.

Files for the coding agent. Databases for the product.

If you're building a consumer app with memory of every user, you want mem0 or Zep. If you're trying to stop your coding agent from re-reading your repo every morning, a structured, file-shaped, human-readable store is almost always the right call, and the interesting question is only who writes it and who can see it.

And on portability: there isn't any. MCP is the de facto standard for transport, donated to the Linux Foundation's Agentic AI Foundation in December 2025. AGENTS.md is the de facto standard for human-authored instructions. For memory content there is no standard and no interchange format. Moving between mem0, Zep, Letta and Cognee means full re-ingestion. Factor that into any decision you expect to live longer than a year.

How to actually pick

Solo, one project, small codebase. Get your CLAUDE.md right. That's it. Don't buy anything.

Solo, several projects, agents running daily. You want automatic capture, because you will not maintain five files by hand. Project Memory or basic-memory.

A team or an agency. Sharing is the whole problem. Ask what it costs for the sixth person to see what the first person's agent learned. With Obsidian Sync that's another paid seat. With Project Memory it's a git clone.

Building a product with per-user memory. Different category entirely. mem0, Zep or Letta, and read the licence terms properly.

You need to know what was true last quarter. Graphiti, and nothing else really competes.

Whatever you pick, the failure mode is always the same and it isn't retrieval. It's a memory nobody trusts, because it's stale and there's no way to tell. Whichever tool you land on, the question to ask first is: how will I know when this has gone out of date? If the answer is "I'll notice eventually", you've picked wrong.

Once memory is sorted, the next thing that quietly degrades agent quality is context rot within a single long session. The canary trick catches it in one line.