Key points
This post surveys ten agent memory frameworks, grouped by the layer of the problem they solve: how to represent memory (protocol), where/how to store it (architecture), and how to learn to use memory (evolution).
Group 1: Protocol & middleware
- Text2Mem — Defines a common "language" for memory: 12 atomic operations (create, read, update, delete, merge, split, verify, etc.), a five-element JSON contract (subject, content, timestamp, importance, related entities), and dual-layer validation. Core insight: without a shared grammar, memory systems are like networks without protocols—everyone talks, no one understands. Best for multi-agent collaboration and cross-system memory sharing.
- Mem0 — A popular open-source memory middleware (https://github.com/mem0ai/mem0) designed to make memory as easy as a database. Features five memory factories (entities, relations, events, preferences, behavior patterns), dual storage (vector for semantic retrieval + graph for relationship tracking), and three memory types (short-term, long-term, semantic). Core insight: good memory should work invisibly. Best for fast integration into AI assistants, chatbots, and companions.
- Letta — Ports OS virtual-memory ideas to agents: Git-style versioned memory (full history of every update) and a "Sleeptime" mechanism where the agent, when idle, asynchronously consolidates memories—summarizing, linking, and pruning, much like the brain during sleep. Best for long-running, continuously growing agents. (https://github.com/letta-ai/letta)
- ReMe — From Alibaba's AgentScope team (https://github.com/modelscope/agentscope). Rejects the "black box" of vector embeddings: memory is stored as plain-text files in a clear directory structure that users can open, read, and directly edit. Core insight: transparency builds trust and enables auditability. Best for enterprise, medical, and compliance-sensitive applications.
- memU — The most radical paradigm: memory itself is a separate agent running 24/7 alongside the main agent. The memory agent actively observes conversations, builds links between new and old memories, periodically reviews the store, and flags contradictions. Three philosophies compared: Letta = automation, ReMe = transparency, memU = agentification. Best for ultra-long-term companionship and deep understanding.
- MemOS — A full "memory operating system" (https://github.com/tencent/MemOS). Unifies all memory types behind an abstraction called MemTensor (like filesystems unifying disks), and provides memory allocation (fast vs. slow storage), garbage collection, and caching. Best for large-scale memory infrastructure.
- OpenViking — From ByteDance/Volcengine (https://github.com/volcengine/openviking). Targets multi-year/decade-scale memory with a Context Database: time-aware retrieval (recency weighting, but important old memories persist), hierarchical compression of old memories, and event anchors on a timeline. Core insight: long-term memory means *selective* forgetting and compression. Best for lifelong companions (health advisors, learning assistants).
- Hindsight/ECHO — Microsoft Research. Every failure hides a "would-have-succeeded" path: analyze the failed trajectory, identify completed subgoals, generate counterfactual trajectories, and create synthetic success cases (Hindsight Experience Replay, borrowed from RL). Reported ~80% improvement over baselines on multi-agent benchmarks. Best for tool use, web browsing, and multi-step planning.
- Second Me — Open-source digital-twin project (https://github.com/mindverse/Second-Me) with a three-layer memory architecture: L0 raw data (conversations, docs, media), L1 natural-language memory (profiles, preferences, events—human-readable and queryable), L2 AI-native memory (knowledge fine-tuned into model weights). Includes Me-Alignment via DPO for personalizing values. Best for AI avatars and "digital legacies."
- MetaMem — From Tsinghua and Northeastern University (https://github.com/OpenBMB/MetaMem). Learns meta-memory: not what to remember, but *how* to remember and retrieve. Through self-reflection on failed answers, it stores retrieval-strategy experience that evolves from task-specific tips to general memory-use patterns. Core insight: the bottleneck is retrieval, not storage. Reported +3.6% on LongMemEval.
- Rapid prototyping: Mem0
- Enterprise apps: ReMe (transparency) or Letta (maturity)
- AI companion: memU + Second Me's three-layer memory
- Learning in complex environments: Hindsight/ECHO
- Multi-year companionship: OpenViking
- Retrieval quality issues: MetaMem
- Mem0: https://github.com/mem0ai/mem0
- Letta: https://github.com/letta-ai/letta
- ReMe: https://github.com/modelscope/agentscope
- MemOS: https://github.com/tencent/MemOS
- OpenViking: https://github.com/volcengine/openviking
- Second Me: https://github.com/mindverse/Second-Me
- MetaMem: https://github.com/OpenBMB/MetaMem
- Text2Mem, memU, Hindsight/ECHO: project links pending in the original post
Group 2: System-level architecture
Group 3: Meta-learning & long-term evolution
Comparison table
| Framework | Positioning | Best for | Key trade-off | |---|---|---|---| | Text2Mem | Protocol/standard | Multi-agent, cross-system sharing | Requires universal adoption | | Mem0 | Memory middleware | Quick integration | Limited deep customization | | Letta | Virtual memory + sleep learning | Long-running, growing agents | Complex, resource-hungry | | ReMe | Transparent file system | User control, auditability | Less automation | | memU | Dual-agent architecture | Ultra-long companionship | Must maintain two agents | | MemOS | Memory OS | Large-scale infrastructure | Full architecture rewrite | | OpenViking | Long-period memory | Years/decades of use | Optimized for the time axis only | | Hindsight/ECHO | Failure → success | Complex-environment learning | Extra compute for synthetic data | | Second Me | Digital twin | AI avatars | Needs lots of personal data + fine-tuning | | MetaMem | Meta-memory learning | Poor retrieval in existing systems | Requires training |
Selection guidance
Closing thought
The author's Feynman-style takeaway: naming is not understanding. Every framework answers the same three questions—how to represent memory, where to store it, how to learn from it—and each embodies trade-offs (automation vs. transparency, developer-friendliness vs. depth). Memory systems are not hard disks; their purpose is to *make intelligence happen*. As Feynman said: *"What I cannot create, I do not understand."*