The idea in one paragraph
Most agent memory works like a filing cabinet: store a chunk, embed it, retrieve the closest chunks later. The A-Mem authors argue that this fixed structure limits how well an agent can learn from experience. Their alternative borrows from the Zettelkasten, the note-taking method where every note is small, carries its own context and links to related notes. In A-Mem the agent itself, through an LLM, decides how a new memory is described, what it links to and which older memories should change because of it. That is what “agentic” means in the title.
How A-Mem works, step by step
- Write a note. Each new memory becomes a note with the original content, a timestamp, and three fields an LLM generates: keywords, tags and a short contextual description. An embedding is computed over all of these together.
- Find neighbors. The system compares the new note with existing notes by cosine similarity and keeps the closest ones (ten by default).
- Let the LLM decide the links. It shows the new note and its neighbors to an LLM, which decides which links to create. Similarity proposes, the model disposes.
- Evolve older memories. For each neighbor, the LLM decides whether its context description and tags should be updated in light of the new note. The updated version replaces the old one.
- Retrieve. A question is embedded the same way, the most similar notes are retrieved, and linked notes come along.
| Part | Classic vector memory | A-Mem |
|---|---|---|
| Unit of memory | A text chunk | A note with keywords, tags and context |
| Links between memories | None, or fixed by the developer | Created by an LLM per new note |
| Effect of new information on old memories | Old entries stay as they were | Older notes can get a new context and tags |
| Cost per write | One embedding | Several LLM calls |
What the paper measured
The authors tested on LoCoMo, a set of very long conversations (about 9,000 tokens on average, up to 35 sessions), and on DialSim, long multi-party dialogues from TV shows. Baselines were the full conversation in context (called LoCoMo in the paper), ReadAgent, MemoryBank and MemGPT, with GPT-4o-mini, GPT-4o, and small Qwen2.5 and Llama 3.2 models.
- Accuracy: A-Mem scored higher than the baselines across the six foundation models in the main results. The clearest gain in the GPT-4o-mini table is on temporal questions (F1 45.85 against 18.41). Read the per-category claims with some care: the gap the text describes for multi-hop questions is much larger than the table shows.
- Tokens: about 1,200 tokens per memory operation, against about 16,900 for the full-context and MemGPT baselines.
- Ablation: removing both link generation and memory evolution hurt most, so the two ideas carry the result.
The authors name their own limits: the quality of the memory depends on the LLM that writes it, different models produce different links, and the implementation handles text only. The paper also reports no error bars or significance tests, citing API cost.
The misunderstanding: “agentic memory” means a better database
The word suggests storage that is smarter. The real shift is that memory becomes a series of model decisions. Every write calls an LLM, and every link and every rewrite of an old note is a judgment that can be wrong. That is powerful, because memory can reorganize itself as understanding grows. It is also why you want to be able to see and undo what the system changed, and why a poisoned or mistaken note can spread through its links. See What is memory poisoning in AI agents? and how such systems are scored in How do you evaluate LLM agent memory?
What this means for a team
A-Mem was evaluated on LoCoMo and DialSim, including multi-party dialogues; these evaluations do not establish permissions or governance for shared team memory. For a team, the useful lesson is the design principle, not the code: a memory that links related knowledge and updates old entries when something changes stays more current than a pile of chunks. The hard parts a team adds are who is allowed to change a shared note, how you keep a history of changes, and how you keep personal context apart from team knowledge. For maintained tools built on related ideas, see Mem0 vs Zep vs Supermemory vs Letta.
Where Bombos fits
Bombos uses the same kind of thinking for a team: a context graph in which knowledge is connected, retrieved by similarity, keywords and nearness in the graph, and updated as the team learns. It is a plugin that gives every AI tool your team uses, from Claude and ChatGPT to Copilot, Cursor and your own agents, one shared memory, and you can trace which notes an answer rests on. One person can try it first for their own agents.
Related questions
Who wrote the A-Mem paper?
Wujiang Xu, Zujie Liang, Kai Mei, Hang Gao, Juntao Tan and Yongfeng Zhang. It was first posted on arXiv (2502.12110) on 17 February 2025 and last revised on 8 October 2025.
Is A-Mem a product I can install?
It is research code. The authors publish two GitHub repositories: one to reproduce the evaluation (WujiangXu/A-mem) and one with the memory system itself (WujiangXu/A-mem-sys). There is no hosted service from the authors.
What does A-Mem cost to run?
The paper reports about 1,200 tokens per memory operation, against about 16,900 for the baselines that keep the full conversation in context, and estimates under $0.0003 per operation through commercial APIs.
What is the difference between A-Mem and Mem0 or Letta?
A-Mem is a research method for organizing memories as linked, self-updating notes. Mem0, Letta and Zep are maintained products and frameworks you can deploy, each with its own way of storing and retrieving memory.
