If you want a Mem0 alternative for coding agents, Agent Ledger 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. Agent Ledger 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

	Agent Ledger	Mem0
Built for	Project memory for coding agents	Memory for any AI app or agent
What gets stored	Entries an agent records on purpose: a decision, lesson, guardrail, note or task	Memories extracted from conversations by an LLM
Search	Postgres full-text search: any of the query's words, title words count most	Semantic search with embeddings
When something changes	The new entry supersedes the old one, which is retired with a pointer to it	Memories can be updated or deleted
Tasks	Tasks with claiming, so two agents don't start the same one	None
MCP	`/mcp` on the API, with an API key or sign-in	Hosted server at `mcp.mem0.ai`, with browser sign-in or an API key
Self-hosting	No, hosted only	Yes: an open-source library and a self-hosted server (Apache 2.0)
Free plan	300 new entries a month; recall unmetered	10,000 add requests and 1,000 retrieval requests a month
First paid plan	$9 a month: 3,000 new entries	$19 a month: 50,000 adds, 5,000 retrievals
Team plan	$49 a month: one shared ledger for the team, 20,000 new entries	Pro, $249 a month: unlimited projects, graph memory

Mem0's figures are from its pricing page, MCP docs and GitHub repository, checked on 21 October 2026. Agent Ledger'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.

Agent Ledger 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-agent-ledger.plxi.us/v1/recall \
  -H "X-API-Key: $AGENT_LEDGER_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 (recall, record_entry, claim_task, retire_entry). The docs show how to connect each client.

Where Mem0 is better

Meaning, not words. Agent Ledger'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 Agent Ledger, 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. Agent Ledger 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. Agent Ledger has no idea of an end user, only projects.

Where Agent Ledger 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).
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. Two sessions never do the same job.
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 Agent Ledger 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

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 agent-ledger https://api-agent-ledger.plxi.us/mcp \
  --header "X-API-Key: $AGENT_LEDGER_KEY"

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

A Mem0 alternative for coding agents' project memory