Both keep knowledge alive across sessions. But they answer different questions: Letta (formerly MemGPT) is a platform for building and running your own stateful agents; Supabrain is plug-and-play memory you add to the coding agent you already use — install, connect over MCP, done.
This isn't local vs cloud — Letta is genuinely open-source and self-hostable too. The real split is scope: Letta gives you the agent itself (identity, tools, runtime, self-managing memory) as a server you operate. Supabrain gives you a focused memory layer you bolt onto the agent you already use — central across your tools, in minutes.
An open-source framework (Apache 2.0) for stateful agents — agents with OS-inspired tiered memory (core, recall, archival) that persist, learn, and self-edit their own memory across sessions.
Powerful and fully yours, but it's a server you operate (Docker self-host or Letta Cloud) plus a vector store for archival. Great for building agents into your own product — Letta Code is its own coding agent built on the platform.
Not an agent — a memory appliance. Install the app, connect it to Claude Code, Cursor, or any MCP client, and your AI work memory is live in minutes — no server to run, no vector store to stand up.
One central memory for all your AI work, local and private by default. Your decisions, fixes, and ruled-out dead ends — recalled in every tool you already use.
Compared on what it actually takes to give the coding agent you already use a lasting memory.
| Capability | Supabrain | Letta |
|---|---|---|
| What it is | A memory layeradded to the agent you already use | An agent platformbuild & run your own stateful agents |
| Setup | Minutesdownload app, connect MCP, done | Run a serverself-host (Docker) or Letta Cloud, then create/configure agents |
| Infra you operate | None | Server + vector storeLetta server plus a vector store for archival memory |
| Local & open | Local-first by defaultstorage, embeddings & search on your machine | Yes — OSS & self-hostApache 2.0, local models, no login (genuine overlap) |
| Memory model | Central, sharedone brain across every MCP client | Per-agent tiered stateeach agent self-edits core/recall/archival |
| What gets stored | Validated conclusionschecked on the way in, incl. dead ends | Agent-curated contextself-edited working memory + history |
| Retrieval | Hybridkeyword (FTS) + semantic | Recall + vector archival |
| Agent ledger | Built inun-skippable, tamper-evident action record | No |
| Best fit | Memory for the agent you use | Building stateful agents you own |
No Letta server, no Docker, no vector store, no agent config. The whole setup is a download and one MCP connection — then the agent you already use remembers.
Every MCP tool shares the same memory. Move from Cursor to Claude Code, swap models, change machines — it follows you. Not per-agent state locked inside one agent you have to operate.
Supabrain adds memory to your existing coding agent. You don't adopt a new runtime, identity, or tool layer — you keep your workflow and gain recall.
Running a server plus per-active-agent metering adds up. Local cost is ~zero, so Supabrain is flat and unlimited — no usage anxiety, no infra to babysit.
It stores validated findings — what was true, what was a dead end — shared centrally, so every tool reasons from results instead of each agent re-curating its own context.
The agent ledger keeps an un-skippable, tamper-evident record of actions, captured at the harness. Memory is voluntary; the ledger is not.
Counter-positioning cuts both ways. Letta is genuinely excellent at a job Supabrain doesn't do — and it's open, local-friendly, and well-built:
Those are builder problems, and Letta is built for them. Supabrain is for the developer who just wants their own work memory — plugged into the agent they already use, central, not a system to operate.
Letta pricing and features as publicly listed, June 2026 — verify current terms on the vendor's site. Plans change. Supabrain team figures are launch pricing for early access.
It depends on the job. Letta (formerly MemGPT) is a platform for building and running stateful agents — you operate a Letta server and create agents that manage their own tiered memory. Supabrain isn't an agent; it's a plug-and-play memory layer you add to the coding agent you already use (Claude Code, Cursor, any MCP client). If you want to add persistent memory to an existing agent in minutes, Supabrain is simpler. If you want to build and own the agent itself, Letta is the right platform.
Both can run locally — Letta is open source (Apache 2.0) and supports self-hosting and local models, so privacy isn't the real wedge here. The difference is operational: Supabrain is local-first by default with no infrastructure to run, while a self-hosted Letta means standing up and maintaining a server plus a vector store for archival memory.
No. Supabrain stores validated work conclusions — structured findings checked on the way in, including ruled-out dead ends — shared centrally across every MCP client. Letta's memory is per-agent self-managed tiered state (core, recall, archival) that each agent curates for itself.
Yes. Supabrain is MCP-native, so it works in any MCP client — Claude Code, Cursor, and others — on any machine. Switch tools or models and your memory comes with you. (Letta can also be exposed over MCP, but that's about managing Letta agents as tools, not adding a turnkey memory layer to your existing agent.)
Install it, connect MCP, and your AI work memory is live in minutes — local, private, and central across every tool you already use. Join the beta for an invite.
✓ Not a concept. We run our entire operations on Supabrain — every day, 2,000+ memories and counting.
Be first in when invites open. No spam — just your invite and the occasional build update.