A Letta alternative for the coding agents you already use

If you want a Letta alternative that gives memory to the coding agents you already use, RepoMemory does that one job. Letta (formerly MemGPT) is a platform for building stateful agents: its own agent harness, Letta Code, keeps an agent's memory and lets the agent rewrite it over time. You switch to a Letta agent to get that memory. RepoMemory works the other way round. Claude Code, Cursor, Codex and any other MCP client keep doing the work, and they share one ledger of the project's decisions, lessons, guardrails and tasks. Letta is the better choice when you want an agent that learns and lives on its own. RepoMemory is the better choice when you want your current agents, and your team, to remember the same things about a codebase.

At a glance

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

How the two work

Letta calls itself "the platform for building stateful agents" (checked 22 October 2026). A Letta agent is a persistent identity with its own memory, model settings, tools and message history. Its memory lives in MemFS, a git-backed set of Markdown files. Files at the root go into the agent's system prompt on every turn. The agent reads and edits them with ordinary file tools, and every edit is a git commit. Its memory page says the agent updates memory when it learns something durable, and background subagents "dream" over recent conversations to tidy it up. Letta's older V1 SDK also had memory blocks and archival memory, a vector store, both now listed under "V1 SDK (legacy)".

RepoMemory doesn't run an agent. It stores what your agents and people record, in one of five kinds, per project. A session starts with brief: every guardrail, the open tasks and the latest decisions. Before a change, the agent recalls with words about it:

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"}'

Agents use the same operations as MCP tools. Because the memory sits outside the agent, Claude Code can record a lesson and Cursor can recall it an hour later. The docs show how to connect each client.

Where Letta is better

• An agent that learns by itself. A Letta agent decides what to remember, writes it to its own memory and consolidates it in the background. With RepoMemory, an agent has to call record_entry, usually because a few lines in CLAUDE.md or AGENTS.md tell it to.
• A whole agent, not just memory. Letta gives you the harness, a CLI, cloud agents, a web chat, channels such as Slack and Telegram, schedules and subagents. RepoMemory is only memory and tasks.
• Building your own product. Letta's Agent SDK lets you embed stateful agents in your own app. RepoMemory isn't a framework.
• Open source and self-hosting. The Letta Code harness is Apache 2.0, and Letta can run locally or on your own App Server. RepoMemory is a hosted service only.
• Search by meaning. Letta's MemFS Search mod adds semantic and hybrid search. RepoMemory's recall matches words, so a query has to share words with the entry.

Where RepoMemory is better

• Keep your agents. RepoMemory adds memory to Claude Code, Cursor, Codex and any MCP client. Letta's hosted MCP lets those clients create and message Letta agents. Its tools are list_agents, list_models, create_agent, send_agent_message, get_run and get_reply, so your agent talks to a Letta agent rather than reading project memory itself.
• One memory for many agents and people. Every key on a team account reads and writes the same ledger, and each entry records who wrote it. Letta's shared memory is git repositories attached to cloud-hosted Letta agents.
• What holds now. Recording a decision with supersedes retires the old one, with a pointer to its replacement. Recall leaves retired entries out.
• Guardrails every session. brief returns every active guardrail, whatever the agent is about to change.
• Tasks for parallel agents. claim_task refuses a task another agent holds. A claim runs out after two hours unless renewed, so a crashed agent never holds work for ever.
• Predictable and cheap. No LLM decides what is stored, and the same query returns the same entries. Only new entries cost credits. recall, brief, claims and retires are free.
• Built for shared, untrusted notes. Results tell the agent that entries are notes, not instructions, and flag one worded like a prompt injection. You can browse, edit, delete, export and import the ledger on the dashboard's Ledger page.

Choose Letta if

• you want an agent that manages and improves its own memory
• you're building stateful agents into your own app
• you want one agent across a CLI, web chat and messaging channels
• you need to self-host or want open-source code

Choose RepoMemory if

• you want to keep using Claude Code, Cursor or Codex
• several agents and teammates should share one memory of a codebase
• you want reversed decisions retired and guardrails always sent
• you run agents in parallel and need them to claim tasks
• you want to see, fix and export what your agents remember

Comparing memory layers too? See our Mem0 alternative page.

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.