# recall vs LangMem

LangMem is LangChain's Python library for agents that learn from their interactions: tools and a background manager that prompt an LLM to write memories into a LangGraph store. recall reads the chats Claude Code, Codex and Cursor 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 · [LangMem on GitHub](https://github.com/langchain-ai/langmem)

## At a glance

LangMem is for people writing agents in LangGraph: it gives the agent a tool to save and search memories as it talks, and a manager that reflects afterwards, each a prompt to an LLM. recall is for people using agents someone else wrote: it reads the transcripts Claude Code, Codex and Cursor keep on disk and gives all three search over them and notes that update overnight.

If you are not building an agent, LangMem has nothing to attach to; if you are, recall will not see its conversations unless they pass through one of those three tools.

| | recall | LangMem |
| --- | --- | --- |
| Runs | On your machine | In your LangGraph agent's process, with a store you run |
| Licence | MIT | MIT; version 0.0.30, pre-1.0 after 21 months |
| Model calls to store a chat | **0** | **1 LLM call per memory operation**, hot path or background |
| A search takes | **11 ms** local, 47 with embeddings | A semantic lookup in your store; no figure published |
| Price | **Free** | Free; LangSmith deployment $0 or $39 a seat plus compute |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to the LLM behind every memory operation |
| Claude Code, Codex, Cursor | MCP, skill, session hook | None: no MCP server, LangGraph only |

## Where both were measured

SWE-ContextBench is the one benchmark both have run. Its authors ran LangMem over the 300 sessions, spending $0.98 and 58 minutes of LLM calls, and found the past fix in its top ten 73.3% of the time; its results are extracted memories rather than sessions. recall 0.5.1 finds it 92.9% at the same cutoff, and 79.8% in its top five, with no model calls.

LangMem publishes no benchmark figures of its own, so there is no chat-benchmark comparison to make. recall's LongMemEval retrieval puts an answering session in the top five 98.7% of the time, and Claude Haiku 5.5 reading its top ten chats answers 88.4% correctly.

**Fig 1. recall 0.5.1 and LangMem** SWE-ContextBench Lite: the past fix behind a new issue, searched over all 300 Claude Code sessions.

| Measure | System | Figure | Note |
| --- | --- | --- | --- |
| Past fix in the top 10 | recall 0.5.1 | 92.9% | hybrid search, no model calls |
| Past fix in the top 10 | LangMem | 73.3% | the paper's run: $0.98 and 58 minutes of LLM calls; ten memories, not sessions |
| Past fix in the top 5 | recall 0.5.1 | 79.8% | hybrid search, no model calls |
| Past fix in the top 5 | recall 0.5.1 · keywords | 77.8% | keyword search only |

SWE-ContextBench Lite, 99 issues, 300 sessions · LangMem publishes no benchmark figures of its own LangMem's figure is the paper's run of a metric it does not define; its ten results are extracted memories rather than sessions, and the paper does not say what it was asked. recall: hybrid search, one run.

## Cost

LangMem's cost is a prompt per memory operation, in the hot path or in a background pass over each conversation. The library is free; LangSmith deployment, if you use it, is $0 or $39 a seat plus metered compute. On SWE-ContextBench the ingest came to $0.98 and an hour for 300 sessions.

recall spends no model calls to index or search. Its only model spend is the nightly notes, with the model you chose: nothing through a local one, covered by a subscription, batch prices on an API key.

| | recall | LangMem |
| --- | --- | --- |
| Model calls to store a chat | **0** | **1 LLM call per memory operation**, hot path or background |
| Price | **Free** | Free; LangSmith deployment $0 or $39 a seat plus compute |
| To take in 300 sessions | **$0**, no model calls | **$0.98**, 58 min of LLM calls |
| Cost of memory | One nightly run, your model | An LLM prompt per memory operation |

## Latency

LangMem's docs say plainly that hot-path memory tools add perceptible latency, which is why the background manager exists. A search is a semantic lookup in your store plus an embedding of the query.

recall's search has no model in the path: 11 ms at the median on ~2,800 chats, 47 ms with the optional embedding model. Nothing is written during a session, so nothing slows one down.

| | recall | LangMem |
| --- | --- | --- |
| A search takes | **11 ms** local, 47 with embeddings | A semantic lookup in your store; no figure published |
| Wait at write time | **None**: reads saved chats | An LLM call in the hot path, or a background pass |

## Privacy

LangMem keeps memories in a store you run, so the data stays with you, but every memory operation sends the conversation to an LLM and semantic search sends text to an embedding model. There is no hosted LangMem service; LangSmith tracing is a separate choice.

recall also keeps everything on your machine, and sends chat text to a model only once a night, redacted, and only if the model you chose is hosted. Indexing and search never call a model.

| | recall | LangMem |
| --- | --- | --- |
| Runs | On your machine | In your LangGraph agent's process, with a store you run |
| Licence | MIT | MIT; version 0.0.30, pre-1.0 after 21 months |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to the LLM behind every memory operation |
| Compliance | Nothing to certify: no service | Yours: nothing is hosted by LangChain |
| Telemetry | **None** | LangSmith tracing, if you enable it |

## How memory is built

LangMem sorts memory into semantic, episodic and procedural, stored as a single evolving profile or a collection of items, each written by prompting an LLM with the current state and the new conversation. It is a toolkit: the shape of the memory is up to the agent you write.

recall's notes are fixed in shape and readable: preferences, project facts, decisions, lessons and open threads, each with a quote from its chat, in markdown under git, consolidated rule by rule once a night. Notes written by Claude Haiku 5.5 hold 91% of the conventions a mentor set on MemoryCode.

| | recall | LangMem |
| --- | --- | --- |
| Captured by | Reading the agents' own chat files | Your agent calling a memory tool |
| Memory is | Markdown notes in git, plus an index of every chat | A profile or a collection of items, in a store |
| Retrieval | Full-text index, five rankings fused; optional local embeddings | Semantic search over store namespaces |
| You can edit it | **Yes**, and the edit wins | Through the store |

## Which to pick

**Pick LangMem if**

- You are writing an agent in LangGraph and want it to save and search its own memories, in a store you control.
- You want memory types and prompts you can shape yourself.
- Your conversations never pass through Claude Code, Codex or Cursor, so there are no transcripts for recall to read.

**Pick recall if**

- You use Claude Code, Codex or Cursor and want them to share a memory of your work with nothing to build.
- You want no model calls to index or search, and the past fix found in the top five four times in five on real issues.
- You want memory you can read as files and revert with git.

## Questions

**Is LangMem still maintained?**

It is updated, mostly dependency bumps, and remains at version 0.0.x after 21 months. LangChain's newer agent memory, in Deep Agents, uses markdown files and does not build on LangMem. recall is released on PyPI as `recall-agents` with a changelog per release.

**Can LangMem give Claude Code or Cursor a memory?**

Not directly: it has no MCP server and no plugin, and is a library for agents written in LangGraph. recall connects to Claude Code, Codex and Cursor through an MCP server, a skill and hooks, and reads their transcripts from disk.

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

On SWE-ContextBench, LangMem found it in its top ten 73.3% of the time in the benchmark's paper, after an hour of LLM calls over the 300 sessions. recall finds it 92.9% at the same cutoff with no model calls. The metric is undefined in the paper and LangMem's results are memories rather than sessions, so compare loosely.

**Could I use both?**

Yes, in different places: LangMem inside an agent you build, recall across the coding agents you use. They do not share a store.

## Sources

- LangMem on GitHub: https://github.com/langchain-ai/langmem
- LangMem conceptual guide: hot path and background memory: https://langchain-ai.github.io/langmem/concepts/conceptual_guide/
- LangMem on PyPI: https://pypi.org/project/langmem/
- LangChain pricing: https://www.langchain.com/pricing
- 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