vsLangMem

LangMem gives agents you build a memory. recall gives the agents you already use one.

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 2026recall 0.5.1LangMem on GitHub ↗

01At 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.

Table 1 · recall and LangMemThe short answers; the sections below take each in turn.

	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

02Where 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.

recall 0.5.1 and LangMemSWE-ContextBench Lite: the past fix behind a new issue, searched over all 300 Claude Code sessions.↑ Higher is better

Fig 1

92.9%of new bug reports have the past fix in recall's top 10

+19.6points over LangMem on the same 300 sessions, with no model calls

Past fix in the top 10

recall 0.5.192.9%
LangMem73.3%

Past fix in the top 5LangMem reports no top-5 figure

recall 0.5.179.8%
recall 0.5.1 · keywords77.8%

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.

03Cost

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.

Table 2 · CostWhat storing and reading memory costs.

	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

04Latency

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.

Table 3 · LatencyWhat an agent waits for.

	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

05Privacy

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.

Table 4 · PrivacyWhere your chat text goes.

	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

06How 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.

Table 5 · How memory is builtWhat is kept, and in what shape.

	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

07Which 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.

08Questions

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.

SourcesLangMem on GitHub · github.com/langchain-ai/langmemLangMem conceptual guide: hot path and background memory · langchain-ai.github.io/langmem/concepts/conceptual_guideLangMem on PyPI · pypi.org/project/langmemLangChain pricing · www.langchain.com/pricingSWE-ContextBench, Zhu et al. · arxiv.org/abs/2602.08316recall's benchmarks and method · github.com/alirng/recall/blob/main/docs/benchmarks.md