Source: Digital Applied — 2026-08-06
Summary
A hands-on architectural comparison of the three leading open-source (Apache-2.0) agent-memory frameworks argues that each encodes a fundamentally different model of "remembering." Letta (formerly MemGPT) treats the LLM like an operating system managing memory tiers — main context, recall store, and archival store. Zep's open-core Graphiti component instead builds a temporal knowledge graph where facts carry validity windows, so contradicted facts are marked superseded rather than overwritten. Mem0 takes a simpler extraction-pipeline approach, pulling salient facts out of conversation as they occur, and the piece closes with a decision rule for when plain RAG over static documents still beats all three.
Key Takeaways
- Letta's OS-inspired design maps directly onto computer memory tiers: main context is like RAM (fast, small, always visible), recall store holds recent conversation history, and archival store is long-term external data the agent pages in on demand.
- Zep/Graphiti's temporal knowledge graph never deletes contradicted facts — it marks the old fact as superseded at a specific point in time, so the agent can reconstruct what it believed and when, not just what's currently true.
- Mem0's extraction pipeline is the simplest of the three: it identifies and stores salient facts as they come up in conversation, trading architectural sophistication for lower implementation overhead.
- None of these three systems is a universal upgrade over plain RAG (retrieval over static documents) — the piece lays out an explicit decision rule for when static-document retrieval is still the better fit than a dedicated memory system.
- The three projects are all Apache-2.0 licensed and open-source, making this a genuine architecture comparison rather than a vendor pricing comparison.
Reel Script
Hook (16s)
If your AI agent forgets what a user told it yesterday, the fix isn't "add more context" — it's picking the right memory architecture. And there are three completely different philosophies on the market right now.
Core Concept (95s)
Here's the problem: large language models don't actually remember anything between calls — every conversation starts from a blank slate unless you engineer memory back in. Three open-source projects tackle this in genuinely different ways. Letta, previously called MemGPT, treats the whole thing like an operating system managing RAM and disk. It gives the agent a "main context" — small, fast, always visible, like RAM — a "recall store" for recent conversation history, and an "archival store" for long-term data the agent can deliberately page in when it needs it, like reaching for a file on disk. Zep takes a totally different approach with its open-core piece called Graphiti: instead of tiers, it builds a temporal knowledge graph, meaning a network of facts where each one carries a "validity window" — a start and end time for when it was true. So if you tell the agent your job title changed, it doesn't erase the old title, it marks it as superseded at that moment in time and keeps both facts on record. Mem0, meanwhile, is the simplest of the three — an extraction pipeline that just pulls out salient facts as they come up and stores them, no graph, no tiers.
Hands-On (130s)
Picture three whiteboards. Letta's whiteboard has three boxes stacked like a memory hierarchy: a small "main context" box the model reads every single turn, a "recall store" box beneath it holding recent chat history, and a bigger "archival store" box off to the side the agent only opens when it explicitly searches it — that's the RAM-versus-disk analogy made literal. Zep's whiteboard looks completely different — it's a graph, dots connected by lines, where every fact-dot has two extra labels stapled to it: a "valid from" date and a "valid until" date. When new information contradicts something, Graphiti doesn't erase the old dot, it just closes its validity window and adds a new dot — so you can ask the graph "what did the agent believe last March" and get a real answer. Mem0's whiteboard is the simplest sketch of the three: conversation goes in one side, a filter pulls out the facts worth keeping, and they land in storage — no tiers, no timestamps, just extraction. And the piece is explicit that none of this beats plain RAG automatically — if your data is mostly static documents rather than an evolving relationship with a user, querying those documents directly can still be the better, simpler call.
Takeaway (24s)
Pick your memory architecture based on what you're actually modeling: Letta for agents that need explicit control over what's "in view," Zep for anything where facts change over time and history matters, Mem0 for the fastest path to "remember what the user said." Go read the piece's decision rule before you default to the fanciest option.