# recall vs Supermemory

Supermemory ingests what you send, runs its own model over it into a vector-graph store, and hands context back at runtime, with plugins for Claude Code, Cursor and Codex. recall reads the transcripts those agents already keep, indexes them with no model calls, and writes notes overnight with a model you choose.

Checked 17 Oct 2026 · recall 0.5.1 · [Supermemory on GitHub](https://github.com/supermemoryai/supermemory)

## At a glance

Supermemory and recall both aim at coding agents and both have plugins for Claude Code, Cursor and Codex. Supermemory's plugins send your sessions to its cloud, where its own model turns them into memories you query over the network. recall never sends the sessions anywhere: it reads the transcript files on disk, indexes them with no model, and writes its notes with whichever model you point it at.

| | recall | Supermemory |
| --- | --- | --- |
| Runs | On your machine | Its cloud; a closed-source self-host binary on the $399 plan |
| Licence | MIT | SDKs MIT; the server is not public |
| Model calls to store a chat | **0** | **Its model at ingest**, or your LLM when self-hosted |
| A search takes | **11 ms** local, 47 with embeddings | **187 ms** server-side, 356 ms end to end |
| Price | **Free** | $5 of credits free; $19, $100, $399 a month; Enterprise |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to its cloud and model, unless self-hosted |
| Claude Code, Codex, Cursor | MCP, skill, session hook | Plugins for Claude Code, Cursor, Codex; hosted MCP server |

## Where both were measured

On SWE-ContextBench, the benchmark's authors found Supermemory put the past fix behind a new issue in its top fifteen 59.6% of the time, after 370k tokens of model calls to take in the 300 sessions. recall 0.5.1 finds it 97.0% at the same cutoff with no model calls, and 79.8% in its top five. The paper does not define its metric, so read the gap loosely.

On LongMemEval, Supermemory reports 85.2% with Gemini 3 Pro and 84.6% with GPT-5, judged by GPT-4o; recall 0.4.1 scores 88.4% with Claude Haiku 5.5 as both. Different models and judges, so the ranking is loose. recall's retrieval alone finds an answering session in the top five 98.7% of the time; Supermemory publishes no retrieval figure.

**Fig 1. recall 0.5.1 and Supermemory** The past fix on SWE-ContextBench, answers correct on LongMemEval, and the latency of a search.

| Measure | System | Figure | Note |
| --- | --- | --- | --- |
| Past fix in the top 15 | recall 0.5.1 | 97.0% | hybrid search, no model calls |
| Past fix in the top 15 | Supermemory | 59.6% | the paper's run: 370k tokens of model calls to take in the sessions |
| Answers correct | recall 0.4.1 | 88.4% | Claude Haiku 5.5 answering and judging, reading the top 10 chats |
| Answers correct | Supermemory · Gemini 3 Pro | 85.2% | its own run, GPT-4o judging |
| Answers correct | Supermemory · GPT-5 | 84.6% | its own run, GPT-4o judging |
| Search latency, median | Supermemory · server | 187 ms | its site's figure; 356 ms end to end |
| Search latency, median | recall 0.4.1 · keywords | 11 ms | ~2,800 chats on a laptop, no model in the path |
| Search latency, median | recall 0.4.1 · hybrid | 47 ms | with the local embedding model, the query's embedding included |

SWE-ContextBench Lite, 99 issues, 300 sessions · LongMemEval_S, Supermemory's own runs · latency from its site and recall's laptop Supermemory's SWE-ContextBench figure is the paper's run of a metric it does not define. Its LongMemEval runs were judged by GPT-4o; recall 0.4.1 used Claude Haiku 5.5 as answer model and judge. Its 97% figure with GPT-4o is labelled Recall@20 with aggregation, not an answer accuracy.

## Cost

Supermemory sells credits: $5 worth free each month, $20 on the $19 Pro plan, $130 on Max at $100, $600 on Scale at $399, the plan that also allows self-hosting. Each ingest spends credits on its model, and a coding agent's sessions are long.

recall costs nothing to index or search. The nightly notes cost what your model costs: nothing with a local one, nothing extra on a Claude or ChatGPT subscription, batch prices on an API key.

| | recall | Supermemory |
| --- | --- | --- |
| Model calls to store a chat | **0** | **Its model at ingest**, or your LLM when self-hosted |
| Price | **Free** | $5 of credits free; $19, $100, $399 a month; Enterprise |
| To take in 300 sessions | **$0**, no model calls | **370k tokens** of model calls, under an hour |
| Cost of memory | One nightly run, your model | Credits, spent at ingest |

## Latency

Supermemory's site gives 187 ms server-side for a search and 356 ms end to end: the round trip to its cloud, with ingest in the background.

recall searches a local index: 11 ms at the median on ~2,800 real chats, 47 ms with the embedding model's ranking. The index updates when the agents write new chats, with nothing to wait for.

| | recall | Supermemory |
| --- | --- | --- |
| A search takes | **11 ms** local, 47 with embeddings | **187 ms** server-side, 356 ms end to end |
| Wait at write time | **None**: reads saved chats | Background ingest and a second model pass |

## Privacy

Supermemory's plugins forward your sessions to its cloud, where its model reads them; it claims SOC 2, a HIPAA BAA and GDPR, but does not say which region holds the data. The self-host build keeps data in an encrypted folder but comes as a binary from a non-public codebase, runs telemetry unless you switch it off, and still needs an LLM key.

recall is open source end to end and reads your chats read-only on your machine. It redacts secrets before indexing, sends no telemetry, and makes no network calls except to the model you chose for the nightly notes. With a local model, nothing leaves.

| | recall | Supermemory |
| --- | --- | --- |
| Runs | On your machine | Its cloud; a closed-source self-host binary on the $399 plan |
| Licence | MIT | SDKs MIT; the server is not public |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to its cloud and model, unless self-hosted |
| Compliance | Nothing to certify: no service | SOC 2, HIPAA BAA, GDPR claimed; no region stated |
| Telemetry | **None** | On by default in the self-host build |

## How memory is built

Supermemory's memory is made by its model: content is chunked and embedded, then a second pass extracts facts, keeps a static and a recent-activity profile, handles contradictions and forgets, inside its temporal vector-graph engine. What it keeps is Supermemory's to show you through its API.

recall's memory is files. The index holds every chat whole; the notes are markdown in git, each with its type, its project and the chats it came from, written once a night and consolidated rule by rule. Notes written by Claude Haiku 5.5 hold 91% of the conventions a mentor set on MemoryCode, and loaded at session start they lift an agent from 32% to 75% on long histories.

| | recall | Supermemory |
| --- | --- | --- |
| Captured by | Reading the agents' own chat files | Plugins forwarding sessions, or your code |
| Memory is | Markdown notes in git, plus an index of every chat | Facts and profiles in a vector-graph engine |
| Retrieval | Full-text index, five rankings fused; optional local embeddings | Vector, full text and graph, with a profile |
| You can edit it | **Yes**, and the edit wins | Through the API |

## Which to pick

**Pick Supermemory if**

- You want a hosted memory API for an application, with user profiles and a graph, and a plugin that also covers your coding agents.
- You are happy for your sessions to be processed by a hosted model, and the credit plans fit.
- You need compliance paperwork from a vendor rather than a tool on your own machine.

**Pick recall if**

- You want your coding agents to remember without any session leaving your machine.
- You want search with no model calls and millisecond latency, over everything the agents ever saved.
- You want memory as readable markdown in git, written by a model you chose.

## Questions

**Is Supermemory open source?**

Its SDKs, tool wrappers and agent skills are MIT, but the server is built from a separate, non-public codebase, and the hosted memory model is Supermemory's own. recall's code is all MIT, and there is no server behind it.

**Which found the past fix more often?**

On SWE-ContextBench, Supermemory put the past fix in its top fifteen 59.6% of the time in the benchmark's paper. recall finds it 97.0% at the same cutoff and 79.8% in its top five, with no model calls. The paper does not define the metric, so compare loosely.

**Can I self-host Supermemory for free?**

Self-hosting is a feature of the $399 Scale plan, and the binary is free within a lite licence limit the docs do not state. You also bring your own LLM key. recall is free to run anywhere, and with a local model costs nothing at all.

**Do both work with Claude Code, Cursor and Codex?**

Yes. Supermemory installs a plugin in each that sends sessions to its cloud and queries it back. recall connects through an MCP server and a `/recall` skill, with a hook that loads your notes at session start; it reads the agents' own transcript files, so no plugin captures anything.

## Sources

- Supermemory on GitHub: https://github.com/supermemoryai/supermemory
- Supermemory: how it works: https://supermemory.ai/docs/concepts/how-it-works
- Supermemory self-hosting and its configuration: https://supermemory.ai/docs/self-hosting
- Supermemory pricing: https://supermemory.ai/pricing
- Supermemory research: LongMemEval runs: https://supermemory.ai/research/longmembench
- SWE-ContextBench, Zhu et al.: https://arxiv.org/abs/2602.08316
- recall's benchmarks and method: https://github.com/alirng/recall/blob/main/docs/benchmarks.md