A Mem0 alternative for coding agents' project memory

If you want a Mem0 alternative for coding agents, RepoMemory is built for that one job. It keeps a project's decisions, lessons, guardrails and tasks, and Claude Code, Cursor, Codex and any other MCP client read it before they change code. Mem0 is a general memory layer that learns about your users from conversations. It is the better choice when you are building an AI product that should remember its users. RepoMemory is the better choice when the "user" is a codebase, and you want every agent working on it to know what was already decided, tried and forbidden.

At a glance

Mem0's figures are from its pricing page, MCP docs and GitHub repository, checked on 21 October 2026. RepoMemory's are on our pricing page.

How the two work

Mem0 watches what a user says and decides what is worth remembering. Its extraction runs an LLM over the conversation, and search runs on embeddings, so "what does Sam like to eat?" can find "Sam is vegetarian". You don't write memories one by one. Mem0 does it for you.

RepoMemory stores only what an agent or a person records, in one of five kinds. A coding agent records a lesson when a change is reverted, a decision when it picks one approach over another, and a guardrail for a rule nobody should break. Before its next change, it recalls with words about that change:

curl -s https://api.repomemory.dev/v1/recall \
  -H "X-API-Key: $REPOMEMORY_KEY" -H "Content-Type: application/json" \
  -d '{"project":"acme/shop","query":"add a captcha to checkout"}'

{"project":"acme/shop","entries":[{"id":"KNOW-1","kind":"lesson",
 "title":"Captcha on checkout cut completed orders 5%",
 "body":"Shipped a captcha on the checkout page in March and reverted it after two weeks: completed orders fell 5%. Bots only spike on release days.",
 "tags":["checkout","captcha"],"status":"active","superseded_by":null,
 "reason":null,"claimed_by":null,"created_at":"2026-10-20T06:00:00.000000+00:00"}],
 "credits":0}

Agents don't usually call the REST API themselves: they use the same operations as MCP tools (brief, recall, record_entry, claim_task, retire_entry). A session starts with brief, which hands the agent every guardrail in full rather than leaving rules to a word match. The docs show how to connect each client.

Where Mem0 is better

• Meaning, not words. RepoMemory's recall matches words. A query has to use words that appear in the entry ("captcha checkout"), not describe the symptom ("why did orders drop"). Mem0's semantic search copes with different wording.
• No writing by hand. Mem0 pulls memories out of conversations without being asked. With RepoMemory, an agent has to call record_entry. In practice, that means a few lines in CLAUDE.md or AGENTS.md telling it when to.
• Open source and self-hosting. Mem0's library and server are Apache 2.0 and run on your own infrastructure. RepoMemory is a hosted service only.
• Volume. Mem0's free plan allows 10,000 adds a month, against Agent Ledger's 300 new entries.
• Memory about people. Mem0 is built to personalise an app for each of its users. RepoMemory has no idea of an end user, only projects.

Where RepoMemory is better

• What holds now, not everything ever said. Recording a new decision with supersedes retires the one it replaces. Recall leaves retired entries out unless you ask for them, so an agent doesn't act on a decision the team has reversed. The old entry is kept, with a pointer to its replacement.
• Predictable recall. There's no LLM or embedding model in the loop, so the same query returns the same entries, and nothing is "remembered" that nobody said.
• Recall costs nothing. Only new entries count against a plan. Recall, claiming and retiring are free and unmetered, within the per-minute rate limit. Agents can recall before every change. Mem0's plans count retrieval requests (1,000 a month on its free plan).
• Guardrails are never missed. brief returns every active guardrail at the start of a session, whatever the agent is about to change, so a rule doesn't depend on a search happening to match it.
• Tasks for parallel agents. claim_task takes the oldest open task, or a named one, and refuses it with 409 already_claimed if another agent has it. A claim runs out after two hours unless renewed, so a crashed agent never holds a task for ever. Two sessions never do the same job.
• Built for shared, untrusted notes. Every result tells the agent the entries are notes, not instructions, and flags one worded like a prompt injection. Each entry records who wrote it, and you can read, edit, delete and export the whole ledger on the dashboard's Ledger page.
• One ledger for a team. Every API key on a team account reads and writes the same ledger, whoever's agent is using it, for $49 a month.

Choose Mem0 if

• you're building an assistant or app that should remember each of its users
• your queries are in natural language and won't share words with what's stored
• you need to self-host or want open-source code
• you'd rather memories were captured for you than recorded on purpose

Choose RepoMemory if

• the memory belongs to a codebase and is shared by several agents and people
• you want reversed decisions retired, not returned alongside the new ones
• your agents should recall before every change without running up a bill
• you run agents in parallel and need them to claim tasks
• you want to see, fix and export what your agents remember

Try it

The free plan needs no card. Sign in, create a key, and add the MCP server to Claude Code:

claude mcp add --transport http repomemory https://api.repomemory.dev/mcp \
  --header "X-API-Key: $REPOMEMORY_KEY"

Cursor, VS Code and Claude.ai use the same URL. See the docs for each, and pricing for the plans.