We Studied Every Major Memory System. None Can Be the Base Layer for Your World

Our founding value says: everyone is unique, and a generic memory cannot solve everyone's problems. A value sounds like a slogan until you hit engineering. Ours did, immediately: if we're going to build a person-centered world: a system that actually knows you: what memory layer does it run on?

Our answer: none of the existing ones. You'd have to build it. This post is the full research trail behind that answer: a systematic review of this generation of memory systems, a side-by-side comparison, and five structural reasons none of them can hold a person. Every claim is cited to a paper you can check: the standing rule of this blog is that all data must be reproducible.

1. The landscape: four families

We surveyed the memory systems from 2023 to today that have either a peer-reviewed paper or a public architecture. They fall into four families.

Family 1: Managed memory layers (product-grade)

• Mem0 (Chhikara et al., 2025, arXiv:2504.19413, ECAI 2025): a two-stage pipeline: extract salient facts from conversations, then decide ADD / UPDATE / DELETE / NOOP against existing memory. Graph variant included. Multi-scope isolation by user_id / agent_id / session_id / app_id.
• Zep / Graphiti (Rasmussen et al., 2025, arXiv:2501.13956): a three-tier temporal knowledge graph: episode (raw messages), semantic entity, community (cluster summaries): with a bi-temporal model (event timeline T plus ingestion timeline Tʹ) that records when a relationship became true and when it stopped being true.
• Letta (formerly MemGPT) (Packer et al., 2023, arXiv:2310.08560, UC Berkeley): treat the context window as RAM and external storage as disk, and let the model page between them itself (virtual context management). Renamed Letta in September 2024; raised a $10M seed.
• Cognee (open-source engineering, no paper): an ECL pipeline (Extract–Cognify–Load) over graph + vector storage, with an API of exactly three verbs: remember / recall / forget.

Family 2: Memory built into commercial assistants

• ChatGPT Memory (OpenAI): launched "saved memories" in April 2024 (things you ask it to remember); since April 2025 the model can also draw on your full chat history; a background "Dreaming" process consolidates memory state, viewable on a memory-summary page.
• Claude Memory (Anthropic): synthesizes a memory summary organized into categories like "Role and Work" and "Current Projects"; a filesystem-based Memory tool ships in the API.
• Gemini Personal Context (Google): stores key user facts in a structured document, user_context: short factual bullets grouped by topic.
• Bedrock AgentCore Memory (AWS): raw events for the short term; an async background process extracts long-term memory (episodic, semantic, user-preference).

Family 3: Academic architectures

• Generative Agents (Park et al., 2023, arXiv:2304.03442, Stanford + Google, UIST 2023): 25 AI residents in a virtual town, each with a natural-language memory stream, retrieval weighted by recency × importance × relevance, and periodic "reflection" that synthesizes observations into higher-level conclusions. Its most famous emergent result: from one line: "throw a Valentine's party": invitations spread on their own, and within two simulated days 13 of 25 residents knew about the party.
• MemoryBank (Zhong et al., arXiv:2305.10250, AAAI 2024, Sun Yat-sen University): mimics the Ebbinghaus forgetting curve, memory strength R(t)=e^-t/S, reinforced on recall. Directly synthesizes a "user personality" profile.
• A-MEM (Xu et al., arXiv:2502.12110, NeurIPS 2025, Rutgers): organizes memory like a Zettelkasten: new memories arrive with structured attributes, auto-link to related history, and trigger updates to older notes.
• HippoRAG (Gutiérrez et al., arXiv:2405.14831, NeurIPS 2024, OSU + Stanford): mimics hippocampal indexing theory with knowledge graphs plus Personalized PageRank; up to 20% better on multi-hop QA than the prior best, at 10–30× lower cost than iterative retrieval.
• Reflexion / ExpeL (arXiv:2303.11366 / arXiv:2308.10144, AAAI 2024): make experience explicit: write a verbal reflection after failure and store it (Reflexion); abstract cross-task insights that can be ADDed, EDITED, UPVOTED, DOWNVOTED (ExpeL: 39.0±1.7% on HotpotQA vs ReAct's 28.0±1.4%).

Family 4: Benchmarks

• LoCoMo (Maharana et al., arXiv:2402.17753, ACL 2024, UNC + USC + Snap): 50 very long dialogues, averaging 300 turns and 9K tokens, spanning up to 35 sessions; five question categories (single-hop / multi-hop / temporal / open-domain / adversarial) plus event summarization and multimodal generation. Headline finding: long-context models lag humans by 56% on memory QA and by 73% on temporal reasoning.
• LongMemEval (Wu et al., arXiv:2410.10813, UCLA + Tencent AI Lab): 500 curated questions across five abilities (information extraction, multi-session reasoning, temporal reasoning, knowledge updates, abstention). Headline finding: commercial assistants and long-context LLMs drop roughly 30% in accuracy across sustained interactions.
• DMR (Deep Memory Retrieval, from the MemGPT team): Zep scores 94.8% vs MemGPT's 93.4%.

2. Side-by-side

Aligned on six dimensions (representative systems only; all have public papers or public architecture docs):

Read the table vertically and one fact surfaces: nine systems, nine data models, but the "top-level entity" column is strikingly uniform. It is a session or an account ID. The one system that makes the user its object, MemoryBank, models the user as a "personality profile." That's where all five gaps come from.

3. Five structural gaps

Gap 1: No identity root: "person" is not a first-class entity

Every system's top abstraction is a conversation or an account. Mem0's user_id isolation is about as granular as it gets; in Zep's entity graph, a person is one extracted entity among companies and concepts. No system builds "person" as an independent first-class citizen with their own identity, roles, relationships, and history.

This isn't any team's implementation sloppiness; it follows from the abstraction. We'll use ourselves as the evidence: in a code audit of one of our in-development projects, we measured three numbers: the intersection of messages.session_id with sessions.id is empty; 13 emotion snapshots have no source; there are 0 event_id foreign keys. In plain terms: messages hang off sessions, sessions don't hang off a person; emotion records have no provenance; events don't reference each other at all. When the base layer has no "person" entity, foreign keys have nothing to point at, and the data drifts into islands. We believe this is an industry-wide pattern rather than our own particular bug, which is why we're publishing the scar.

Gap 2: Conflict resolution is fact-level; a human world is relation-level

This is the subtlest gap. Watch how existing systems handle contradictions: Mem0 has an LLM choose among ADD/UPDATE/DELETE/NOOP; Zep uses bi-temporal timestamps to expire old relations; MemoryBank lets old memories decay. All of them answer one question: is this fact stale?

But in a human world, most information isn't a two-valued stale/fresh. It's "to whom, in which role, meaning what." Is "my salary is $X" the same piece of information to your partner, your boss, your lender, and your parents? In these models it gets extracted into one triple and then updated or forgotten on a schedule: its relation to every context is the same value. Our value says a person is the sum of their relationships, and in engineering that means: the first-class property of a piece of information is not its content but the relationship it belongs to. The same fact carries different meaning, visibility, and lifecycle in different relationships. Not one of the nine systems has that dimension.

Gap 3: User modeling = profile synthesis = the average model

MemoryBank synthesizes a user personality. Gemini's user_context is topic-organized facts. Claude's memory summary is a category tree. ChatGPT's saved memories are flat notes. Different formats, same essence: distilling a person into "a file about them."

Statistically, this is the user mean: compressing everything a person reveals across countless interactions into one description true of the average them. But a person is not a file. The same human is a different person as a daughter, as an engineer, as someone in debt, as a first-generation immigrant; flatten those into one list and the uniqueness is gone before you start. That is the engineering form of our value, verbatim: "a generic memory cannot solve everyone's problems": when a memory system's output is a generic profile, it cannot, in principle, solve anyone's particular problem.

Gap 4: Forgetting as cache policy, not as a right

MemoryBank's Ebbinghaus decay exists to save context window. Commercial assistants' delete buttons exist for compliance. Both treat forgetting as an engineering means of the system. But in product semantics, being forgotten should be the user's exercise of sovereignty over data about themselves: deciding what is recorded, what isn't, when to revoke, and having revocation take the derived summaries down with it. In existing systems you can manage a list of saved memories, but what the model "learned" from your history is neither fully visible nor fully deletable.

There's a subtler failure too: automatic decay errs in both directions at once: what should be forgotten isn't (an embarrassing conversation from ten years ago still surfaces in retrieval), and what shouldn't be is (last week's promise to family decays as a low-weight memory). Because the decay function only knows "how long since last access," never "how much this matters to this person."

Gap 5: The benchmarks don't measure the person

This gap shapes the whole field's direction, so we put it last but it may matter most. Look at what the two main benchmarks test: LoCoMo tests recall QA, event summarization, multimodal generation; LongMemEval tests extraction, multi-session reasoning, temporal reasoning, knowledge updates, abstention. All of it is the "recall QA" paradigm: memory as a document corpus to be retrieved, "remembers accurately" as the definition of "memory works."

No benchmark tests identity consistency (is this the same person across contexts), relationship evolution (ex becomes colleague, colleague becomes co-founder: does the system keep up), cross-context continuity (should what's known in context A be used in context B), or consent and revocation (when a user says "forget this," where do the derived artifacts go). Proving a memory system with LoCoMo scores is like proving education with exam scores: the ruler is hard, but it isn't measuring the thing you care about. The field optimizes recall F1, and "holding a person" never enters the objective function.

4. So what should the base layer look like

Pointing at gaps is easy. Stating a direction and admitting the distance is the point of this post. Our design constraints (some implemented, some in research):

1. Person is a first-class entity; relationship is a first-class entity. Memory hangs off person × relationship-scenario, not off sessions; the same fact in different relationship scenarios is a different record with its own visibility and lifecycle. Scenario (case-scoped) is a namespace, not a tag.
2. Confirmation-based promotion, never automatic synthesis. The system may suggest "this is what this is about you," but writing into long-term memory requires human confirmation. Our own cautionary example: the code once had an auto-confirm rule (same content shown a few times → automatically confirmed): "the system confirming on your behalf" is itself anti-autonomy, and it's on the fix list. Against MemoryBank-style automatic profile synthesis, this is a directional difference.
3. Fixed output contract. Whenever memory is used, the output must carry provenance and scenario: who said this, in which scenario, when. Memory without provenance doesn't get into answers.
4. Forgetting is the user's right. Revocation invalidates derived summaries together with the record, and is visible and auditable by default.
5. Our own evaluation. We use the public benchmarks as reference lines (LoCoMo, LongMemEval), but acceptance must include the dimensions listed in Gap 5. A memory system's exam is not the memory field's exam: it's the person's.

5. One closing line

Everyone is unique. In engineering, the first line of that sentence is the first line of the definition of the "person" entity in the base data model. Existing memory systems gave the top-level slot to sessions and accounts, so they can remember what you said, but they cannot hold who you are. Our direction differs from line one.

Next up: what "generic memory vs person-centered memory" means concretely in engineering: the same data, two models, two very different things that grow out of them.

References (check them yourself)

1. Chhikara, P., Khant, D., Aryan, S., Singh, T., & Yadav, D. (2025). Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory. arXiv:2504.19413.
2. Rasmussen, P., Paliychuk, P., Beauvais, T., Ryan, J., & Chalef, D. (2025). Zep: A Temporal Knowledge Graph Architecture for Agent Memory. arXiv:2501.13956.
3. Packer, C., Wooders, S., Lin, K., Fang, V., Patil, S. G., Stoica, I., & Gonzalez, J. E. (2023). MemGPT: Towards LLMs as Operating Systems. arXiv:2310.08560.
4. Park, J. S., O'Brien, J. C., Cai, C. J., Morris, M. R., Liang, P., & Bernstein, M. S. (2023). Generative Agents: Interactive Simulacra of Human Behavior. arXiv:2304.03442. UIST 2023.
5. Zhong, W., Guo, L., Gao, Q., Ye, H., & Wang, Y. (2024). MemoryBank: Enhancing Large Language Models with Long-Term Memory. arXiv:2305.10250. AAAI 2024.
6. Xu, W., Liang, Z., Mei, K., Gao, H., Tan, J., & Zhang, Y. (2025). A-MEM: Agentic Memory for LLM Agents. arXiv:2502.12110.
7. Gutiérrez, B. J., Shu, Y., Gu, Y., Yasunaga, M., & Su, Y. (2024). HippoRAG: Neurobiologically Inspired Long-Term Memory for Large Language Models. arXiv:2405.14831. NeurIPS 2024.
8. Shinn, N., et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv:2303.11366.
9. Zhao, A., et al. (2024). ExpeL: LLM Agents Are Experiential Learners. arXiv:2308.10144. AAAI 2024.
10. Maharana, A., Lee, D.-H., Tulyakov, S., Bansal, M., Barbieri, F., & Fang, Y. (2024). Evaluating Very Long-Term Conversational Memory of LLM Agents. arXiv:2402.17753. ACL 2024.
11. Wu, D., Wang, H., Yu, W., Zhang, Y., Chang, K.-W., & Yu, D. (2024). LongMemEval: Benchmarking Chat Assistants with Long-Term Interactive Memory. arXiv:2410.10813.