6 Best Supermemory Alternatives for Open and Governed Agent Memory in 2026

The best Supermemory alternative for teams that need to read their memory engine’s source, self-host it reliably, or govern what several agents share is Caura. Its full engine is Apache 2.0 on PostgreSQL; it scans every write for PII before storing it, and eToro runs it across 300+ agents.

Supermemory’s self-hosted server, by contrast, ships as a compiled binary at version 0.0.x, and its issue tracker shows snapshots crashing past about 150 MB of data. Mem0, Hindsight, Cognee, Zep, and Letta each fit a narrower reason for leaving, covered below.

Supermemory alternatives covered:

• Caura: open-source governed memory with PII quarantine, audit trails, and per-agent trust levels.
• Mem0: the most adopted open-source memory API, for single-agent personalization.
• Hindsight: an MIT-licensed memory engine that runs as one container.
• Cognee: a knowledge graph built from your documents, code, and tickets.
• Zep: managed temporal memory with SOC 2 Type II and HIPAA on its Enterprise plan.
• Letta: a stateful coding agent that maintains its own memory.

Why do teams choose Supermemory in the first place?

Supermemory made memory easy to add to the tools developers already use. It ships plugins and an MCP server for Claude Code, Cursor, Codex, and OpenCode, so a coding agent can remember a project across sessions after one install. One API covers three jobs: a memory graph per user with profiles and facts, document retrieval it calls SuperRAG, and connectors that sync Gmail, S3 or a web crawl into the same store.

It also markets well on numbers. The supermemoryai/supermemory repository has 31.0k GitHub stars as of 30 September 2026; the README reports first place on LongMemEval, LoCoMo and ConvoMem, and the pricing page advertises a 187 ms median recall. As of 30 September 2026, paid plans start at $19 a month.

That combination fits a single developer or a small product team well. The reasons people search for Supermemory alternatives appear when a team needs to self-host it, audit it, or let several agents share it safely.

Why are Supermemory users looking for alternatives?

Six problems recur in Supermemory’s own issue tracker, README, and pricing page.

1. The memory engine is a compiled binary

Supermemory’s plugins, SDKs, and MCP server are open source. The memory engine behind them is not. Its README describes self-hosting as “one binary, zero config”, and users configuring it have had to read strings out of that binary to find which settings exist, as one reporter did in issue #1104. If your security review requires reading the code that extracts, stores, and ranks your users’ data, Supermemory cannot pass it.

2. The self-hosted server is still at version 0.0.x, and it shows

The self-hosted server persists data by serializing the whole database into one snapshot. In issue #1177, that snapshot fails with an out-of-memory error once the database reaches about 150 MB, then loops on the CPU until a lossy cleanup. Issue #1413 shows the same design rewriting the entire database every 10 seconds on a hard-coded timer, even when a few hundred bytes changed.

Upgrades carry their own risk. After moving from 0.0.7-rc.2 to the 0.0.7 release, one user found every pre-existing document returned zero results for both keyword and semantic search, because the vector format changed underneath them. Another reported the server crash-looping under sustained ingestion, with shorter gaps between crashes each time.

3. Self-hosted configuration does not always take effect

The local embedding model is hard-coded to an English-only model, so a German memory could not be found even by its own verbatim code word in issue #1104. Issue #1336 reports that the embedding provider environment variables are ignored altogether. And issue #1454 shows memory relations never populating on self-hosted servers, even when running the docs’ own canonical example.

4. Compliance and access control start at the $399 Scale plan

As of 30 September 2026, Supermemory bills per unique token ingested: $5 per million tokens for plain-text memory, $10 for rich content, and $5 per million search queries. Those usage rates are low. The gates sit elsewhere. SOC 2, the HIPAA BAA, per-tag access control, and the self-hosted option are listed on the Scale plan at $399 a month, and air-gapped self-hosting sits on Enterprise.

5. Nothing governs what flows from memory into the model

One of the most-discussed open requests in the tracker, issue #1348, describes three gaps for regulated teams. A user’s shared SSN is extracted as a fact and flows into any agent that reads that profile, with no scan or redaction. A poisoned document synced through a connector becomes part of every later retrieval for that container. And there is no audit trail of what was retrieved or by whom. Once more than one agent reads the same memory, each gap multiplies.

6. The headline benchmark numbers are self-reported

Supermemory’s first-place claims come from its own runs. Maximem’s public LongMemEval comparison reports a 71.3% score for Supermemory on Maximem’s own harness. Neither number is neutral, which is the point: ask for the evaluation code and judge model behind any memory score before it decides your architecture.

What do Supermemory alternatives roundups leave out?

We read the four pages currently ranking for “Supermemory alternatives” and counted the tools named and the problems covered.

Across 8,681 words, none of the four covers the self-hosted server’s stability issues above. One still says Supermemory has no self-hosted option without an enterprise agreement, which the current README contradicts. None evaluates PII handling, retrieval auditing or what happens when two agents share one container. The word “fleet” does not appear once.

Where is Supermemory actually strong, and what fully replaces it there?

Supermemory does three things well. A replacement only counts if it covers the one you rely on.

Memory inside coding agents

Supermemory’s plugins are the fastest way to give Claude Code or Cursor a persistent project memory. Caura covers the same clients through its MCP server with one config block, and adds what a team needs once several developers’ agents write to the same project memory: scopes, trust levels, and an audit trail. Letta Code is the option if you want the coding agent itself to own and edit its memory.

Documents and memory from one API

SuperRAG puts document retrieval next to user memory. Cognee is the closest open-source replacement for that job, building a knowledge graph from documents, code, and tickets you can run yourself.

Managed compliance

If you are on Scale for SOC 2 and HIPAA, Zep’s Enterprise plan is the like-for-like managed alternative, with SOC 2 Type II, a HIPAA BAA, and audit logs. Self-hosting an open engine such as Caura or Hindsight moves the compliance boundary inside your own infrastructure instead.

How do the best Supermemory alternatives compare?

The table scores each of the six Supermemory alternatives on the reasons teams leave.

1. Caura: open, governed memory for agents that share context

Repository: github.com/caura-ai/caura

Caura is the Supermemory alternative for teams that need to see, run and govern the whole memory engine. An agent writes plain text with caura_write. One LLM pass classifies it, extracts entities into a knowledge graph, scans for PII, checks for contradictions and stamps its visibility scope before it lands. Any authorized agent recalls it through hybrid vector, keyword and graph search.

How Caura answers each reason teams leave Supermemory

Readable engine: The open-source release is the complete system: storage, contradiction detection, supersession chain, audit trail, and all 12 MCP tools. Nothing in the pipeline is a binary you have to reverse-engineer.

Storage you already know how to run: Caura persists to PostgreSQL with pgvector, started with docker compose up. Backups, replication, and upgrades follow the Postgres practices your team already has, instead of a monolithic snapshot file. A local embedder profile runs air-gapped with zero outbound API calls.

PII handled at write time: The write pipeline detects PII and quarantines it before the memory becomes searchable, which is the gap issue #1348 asks Supermemory to close. Every write, update, and delete is recorded in the audit trail.

Governance across agents: Each agent carries a trust level checked on every call: standard agents read and write only in their own fleet, cross-fleet agents can read wider, and only admin agents can delete memories. Keystones serve mandatory rules to every agent at session start, so a policy cannot scroll out of context. The caura-cross-fleet-gov demo enforces fleet boundaries as a SQL predicate on every recall.

Pricing that ignores agent count: Every plan, including Free, allows unlimited agents, fleets, and users. As of 30 September 2026, Pro is $49 a month ($41 billed annually) for 250,000 memories and 50,000 searches, on the pricing page.

Caura benchmark results and production proof

Caura scores 92.2% on LongMemEval, 461 of 500 questions under the benchmark’s reference GPT-4o judge, with a 22.4k-token median context. In a separate warm, single-tenant benchmark, search ran at 23 ms p50. The evaluation code, saved contexts and per-question verdicts are public in caura-longmemeval, so you can rerun the number instead of trusting it. The benchmark write-up also reports 82.5% on LoCoMo. In production, eToro’s Company Brain runs 300+ agents on Caura with 26,500+ memories and 1,372 shared skills.

Where Caura is weaker: it has no consumer app or browser extension, and no built-in Gmail or S3 connectors. The community is much smaller than Supermemory’s.

Best for: teams that need an auditable, self-hostable engine, and any team where several agents or developers write to the same memory.

2. Mem0: the most adopted open-source memory API

Repository: github.com/mem0ai/mem0

Mem0 is the default open-source swap for Supermemory’s memory API: add() stores, search() retrieves, and the source is readable end to end. Its v3 algorithm keeps both old and new versions of a changed fact, which leaves choosing the current one to your code, as users describe in issue #4956. Entity linking and audit logs sit on paid tiers, at $249 Pro and Enterprise respectively.

Best for: single-agent personalization where the main reason to leave was the closed engine.

3. Hindsight: MIT memory that runs as one container

Repository: github.com/vectorize-io/hindsight

Hindsight is the most direct fix for Supermemory’s self-hosting problems: one Docker command, embedded Postgres, every feature in the free MIT release. It stores memories in banks with retain, recall and reflect operations and runs several retrieval strategies per query. Its README states its LongMemEval results were independently reproduced by Virginia Tech’s Sanghani Center. Watch its LLM usage, since retain and reflect both call a model.

Best for: teams that want Supermemory-style recall on their own servers with no license restrictions.

4. Cognee: a knowledge graph built from your documents

Repository: github.com/topoteretes/cognee

Cognee replaces the SuperRAG half of Supermemory. It turns documents, code, tickets and conversations into a knowledge graph through remember, recall, improve and forget, and its managed Standard plan adds Slack, Notion, Linear and Google Drive connectors. Conflict resolution and provenance are listed on its Enterprise plan, so check which features your deployment includes.

Best for: agents that answer from a body of existing documentation.

5. Zep: managed temporal memory with enterprise compliance

Repository: github.com/getzep/graphiti

Zep runs on Graphiti, an open-source temporal knowledge graph that tracks when each fact was true. Its managed platform reserves SOC 2 Type II, a HIPAA BAA and audit logs for Enterprise in its plan comparison, which makes it the closest managed replacement for Supermemory’s Scale compliance. It bills by bytes written, with retrieval unmetered. Our Zep alternatives guide covers its trade-offs in full.

Best for: regulated teams that want a managed vendor and need facts tracked over time.

6. Letta: a coding agent that keeps its own memory

Repository: github.com/letta-ai/letta

If you used Supermemory mainly as memory for a coding agent, Letta Code offers a different model: the agent itself rewrites its memory blocks and skills, and all context is tracked in git. That replaces the plugin with a whole agent. Letta moved its Python server to an archive branch in August 2026, so new work happens in the TypeScript Letta Code, covered in our Letta alternatives guide.

Best for: developers who want a persistent coding agent more than a memory API.

How do you choose the right Supermemory alternative?

Start with the reason you are leaving Supermemory, then answer four questions before you migrate.

Do you need to read the engine’s source?

If security review requires it, keep to Caura, Mem0, Hindsight, Cognee or Graphiti. All five publish the code that extracts and ranks memories.

Where will memory run, and who maintains it?

Postgres-backed engines (Caura, Hindsight) fit teams that already operate Postgres. Graphiti needs a graph database. Managed plans (Zep, Mem0, Cognee Cloud) keep operations with the vendor.

What should never reach the model?

Write down the data classes your agents must not see: government IDs, card numbers, health details. Then test each candidate by storing one and recalling it from a second agent. Caura quarantines it at write time. Most alternatives return it.

How many agents write to the same memory?

One writer means isolation by user or container is enough. Several writers need provenance, trust, and contradiction handling, which Caura’s guide to agent fleet memory walks through field by field.

Which Supermemory alternative should you pick?

Pick Caura if you need an open engine you can audit, reliable self-hosting on Postgres, PII handling before storage, or governed memory shared across agents. It is the only option here that combines all four, and it runs in production at 300+ agents.

For a single agent, pick Mem0 for the largest community, Hindsight for a one-container MIT self-host, Cognee for document graphs, Zep for managed compliance, and Letta if you want a coding agent that owns its memory.

If you are on Supermemory today, the fastest test is to connect Claude Code or Cursor to Caura’s free tier through its MCP server, write a fact containing a fake SSN from one session, and try to recall it from another. What comes back tells you whether your memory layer is ready for more than one agent.

Frequently Asked Questions

Is Supermemory open source?

Partly. Its SDKs, plugins and MCP server are open source in the supermemoryai/supermemory repository. The memory engine used for self-hosting ships as a compiled binary, and air-gapped self-hosting is an Enterprise feature.

Can I self-host Supermemory?

Yes, with the local server binary, which is at version 0.0.x. Users have reported snapshot crashes past about 150 MB of data, full-database rewrites every 10 seconds, and an upgrade that made older documents unsearchable. Test upgrades on a copy of your data first.

How much does Supermemory cost?

As of 30 September 2026, Supermemory is free with $5 of monthly credits, then $19 Pro, $100 Max, and $399 Scale, each including a credit balance. Usage is billed at $5 per million memory tokens for plain text, $10 for rich content, and $5 per million searches. SOC 2, HIPAA, and the self-hosted option are listed on Scale.

What is the best open-source Supermemory alternative?

Caura is the best open-source option when several agents share memory, or you need PII and audit controls, under Apache 2.0. Mem0 has the largest community, Hindsight is the simplest MIT self-host, and Cognee is strongest for document graphs.

Which Supermemory alternative works with Claude Code and Cursor?

Caura, Mem0, Hindsight, and Cognee all expose MCP servers that Claude Code and Cursor can use. Caura connects with one config block and applies the same scopes and trust levels to coding agents as to any other agent.

Does Supermemory redact PII before it reaches the LLM?

Not today, according to an open request in its issue tracker that asks for PII redaction, context-poisoning defense, and an audit trail between memory retrieval and the model. Caura scans every write for PII and quarantines it before it becomes searchable.

Related reading: What Is Agent Fleet Memory? · Caura on LongMemEval · Governed Shared Memory paper