The idea in one paragraph
Long conversations are mostly redundant. Storing them in full makes an agent slow and expensive, and storing them as raw chunks leaves pronouns and relative dates (“he said he’d do it tomorrow”) that mean nothing out of context. SimpleMem’s answer is compression that keeps meaning: throw away what carries no information, and rewrite what remains into short facts that stand on their own. The authors call this semantic lossless compression.
How SimpleMem works, step by step
- Slide a window over the dialogue. Incoming conversation is cut into overlapping windows, 20 turns long with a stride of 5 in the reported setup.
- Filter. An LLM reads each window. If it finds nothing worth keeping, as in pure small talk, the window is discarded.
- Rewrite into memory units. Informative windows become atomic facts. Pronouns are replaced by names (coreference resolution) and relative times become absolute ISO-8601 timestamps, so each fact is self-contained.
- Index three ways. Every unit gets a dense embedding for meaning, a BM25-style keyword index for exact names and terms, and structured metadata such as timestamps and entity types in SQL. The implementation stores this in LanceDB.
- Merge at write time. Related fragments are combined before they are saved. The paper’s example turns “wants coffee”, “prefers oat milk” and “likes it hot” into one entry.
- Plan the retrieval. For each question, an LLM planner writes a semantic, a keyword and a metadata query and picks how deep to search (between 3 and 20 candidates per view). The three result sets are combined and deduplicated.
| Part | Typical chunk memory | SimpleMem |
|---|---|---|
| What is stored | Raw dialogue chunks | Filtered, self-contained facts |
| Names and dates | As spoken (“she”, “next week”) | Resolved names, absolute timestamps |
| Index | One embedding | Embedding, keywords and metadata |
| Related facts | Stored separately | Merged at write time |
| Retrieval depth | Fixed top-k | Chosen per question by a planner |
What the paper measured
The authors tested on LoCoMo and LongMemEval-S against full context, ReadAgent, MemoryBank, MemGPT, A-Mem, LightMem and Mem0.
- LoCoMo with GPT-4.1-mini: average F1 of 43.24 for SimpleMem, 34.20 for Mem0 and 18.70 for the full-context baseline. Tokens per query: 531, 973 and 16,910.
- LongMemEval-S with GPT-4.1-mini: average accuracy 76.87% against 59.81% for Mem0 and 39.57% for full context.
- Speed: on a LoCoMo subset, total time per sample was 480.9 seconds against 1,934.3 seconds for Mem0, mostly because building the memory was much faster.
Read the results with care. They are the authors’ own runs, the gap shrinks with other models (with GPT-4o, 39.06 against 36.09 F1), and on some metrics, such as BLEU for temporal questions with GPT-4o, Mem0 scored higher. The paper has no separate limitations section. How to read such numbers in general: How do you evaluate LLM agent memory?
The misunderstanding: smaller memory means less memory
The striking number is the token cut, so it is easy to think SimpleMem simply remembers less. The point is the opposite: by removing noise and making each fact self-contained, the agent can afford to retrieve the right facts and still stay within budget. Compression is a quality step, not only a cost step. The risk sits in the LLM that does the filtering and rewriting: if it drops or distorts a fact, nothing downstream can bring it back.
What this means for a team
The paper studies conversations with one user. For a team, the transferable lessons are concrete. Write memories that make sense without their original conversation, with names and dates spelled out, because a colleague or another tool will read them later without that context. Combine meaning-based search with exact keyword and date search, because team questions often hinge on a project name or a deadline. And merge related knowledge into one place instead of letting near-duplicates pile up. Compare with another research design in What is A-Mem? and with maintained products in Mem0 vs Zep vs Supermemory vs Letta.
Where Bombos fits
SimpleMem studies memory for one user’s conversations. Bombos is a plugin that brings memory to a whole team: a shared memory layer underneath Claude, ChatGPT, Copilot, Grok, Codex, Cursor and your own agents. It learns how your team works, draws on mail, documents and repos, and shows with every answer which notes it rests on. One person can try it first with their own agents.
Related questions
Who made SimpleMem?
Jiaqi Liu, Yaofeng Su, Peng Xia, Siwei Han, Mingyu Ding and Huaxiu Yao at UNC-Chapel Hill, with Zeyu Zheng (UC Berkeley) and Cihang Xie (UC Santa Cruz). The paper is arXiv 2601.02553, first posted 5 January 2026.
Is SimpleMem better than Mem0?
In the paper's own LoCoMo tests with GPT-4.1-mini, SimpleMem scored an average F1 of 43.24 against 34.20 for Mem0, with about half the tokens per query. These are the authors' runs; on some metrics with other models Mem0 scored higher.
Can I use SimpleMem in production?
The code is open source at github.com/aiming-lab/SimpleMem. The authors also offer a cloud-hosted MCP service at mcp.simplemem.cloud, alongside local self-hosting.
What does 'semantic lossless compression' mean here?
Making memory much shorter without losing the facts that matter: dropping chit-chat, and rewriting what remains so each fact can be understood on its own.
