Six frameworks dominate the 2026 long-term memory landscape, and each starts from a different core abstraction. Knowing which is which matters when you pick one for a product.
**Mem0** treats memory as **extracted user facts behind a managed API**. After every turn, an LLM extraction pass converts dialogue into discrete facts and stores them with embeddings. Before the next turn, the top-k relevant facts are retrieved and injected. The developer mostly calls a SaaS API.
**Letta (formerly MemGPT)** treats memory as **OS-style paged blocks edited by the model**. Named blocks (persona, human, archival) live alongside the context window. The model invokes tool calls to read, write, search, and evict blocks. Eviction is part of the trajectory rather than an external policy.
**Zep** treats memory as a **temporal knowledge graph**. The Graphiti engine extracts entities and relationships from dialogue and stores them with valid-from and invalid-from timestamps. Retrieval is a graph traversal that respects time, so you can ask 'what did the user say about X as of March?'
**LangGraph state** treats memory as a **typed checkpointed state object**. The developer defines a TypedDict with slots like messages, plan, summary, tool results. Each slot has a reducer. Every node serializes the state to a checkpointer for pause and resume.
**LangChain ConversationSummaryBufferMemory** is the **sliding buffer plus running summary** pattern: the most recent N turns live verbatim, older turns compress into a running summary that grows incrementally.
**AutoGen state managers** give each agent its own state (messages, tool history) with **customizable summarization** hooks. The framework provides the shape; the developer fills in the summarization logic.
The 2026 memory framework landscape has converged on six distinct **core abstractions**, and matching each tool to its abstraction is what makes selection rational.
**Mem0** is **LLM-extracted facts behind a managed API**. The extraction LLM converts dialogue into structured facts (declarative statements about the user), deduplicates them, resolves contradictions, and stores them with embeddings. At retrieval time, the relevant facts are fetched by vector search and injected into the prompt. The developer mostly interacts with a SaaS API: `mem0.add(messages)`, `mem0.search(query, user_id)`. The complexity of extraction, dedup, and decay lives inside the service.
**Letta (formerly MemGPT)** is **OS-inspired memory blocks edited by the model via tool calls**. The MemGPT paper framed memory as virtual memory: the context window is fast main memory and external stores are slow disk. Letta operationalizes this with named blocks (`persona`, `human`, `archival`, `recall`) and exposes edit tools (`core_memory_append`, `archival_memory_search`, `archival_memory_insert`). The model itself decides when to recall, when to write, when to evict. Memory management becomes a trajectory event rather than a framework policy.
**Zep** is a **temporal knowledge graph with dated facts**. The Graphiti engine (Zep's open-source memory engine) extracts entities and relationships from dialogue and stores them as graph edges with explicit `valid_from` and `invalid_from` timestamps. Retrieval is a hybrid of vector search and graph traversal that respects time. This is the only framework with a first-class temporal model: it can answer 'what was true as of March' and 'when did this fact become invalid' natively.
**LangGraph state** is a **typed state object that flows through graph nodes and supports checkpointing**. State is a TypedDict (or Pydantic model) with named slots and per-slot reducers.
Quick reference
TL;DR
Mem0 stores extracted facts behind an API; Letta exposes OS-style memory blocks edited by tool calls; Zep builds a temporal knowledge graph; LangGraph offers typed checkpointed state; LangChain summary-buffer mixes
Imagine six different librarians, each with a different way to remember what you have asked about. One writes sticky notes after every conversation and hands you the relevant ones the next time you walk in (Mem0). One has labeled drawers you can open or rearrange yourself (Letta). One draws a family tree of facts with dates so they can tell you when something was true (Zep). One keeps your whole case file in a folder with named tabs and saves a copy at every step (LangGraph). One keeps the last few pages of notes plus a one-paragraph summary of everything older (LangChain). And one assigns a junior librarian to each topic with their own way to summarize (AutoGen). Same job, six designs.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Stateless transformation tools (summarization, translation) where there is no user across calls None of the six frameworks add value when there is no continuity to remember. Pure prompt engineering applies.
Single-user demos or research scripts where memory complexity is the wrong place to spend time A list of messages in code is enough. Pulling in any framework adds dependencies and concepts that the project does not need.
Workloads where memory is governed by external regulatory rules (PII boundaries, retention limits) None of the off the shelf frameworks model regulatory constraints natively. You will need to wrap or extend, and sometimes building bespoke is cleaner than fighting the framework's defaults.
Quick scan · 2–4 min
Everything important, quickly.
Walk the six frameworks in order: Mem0 (extracted facts, managed API), Letta (OS-style blocks, model-edited), Zep (temporal knowledge graph), LangGraph state (typed checkpointed orchestration), LangChain summary-buffer (chat-style recent plus rolling summary), AutoGen state managers (per-agent state with hooks). For each, name the core abstraction in one phrase and the workload it suits. Close by recommending one long-term memory framework plus one orchestration primitive rather than stacking multiple memory systems.
Real-world examples
Real products, models, and research that use this idea.
1Mem0 is used in production by personal assistants like Pi and Inflection's product line for fact-style memory
2Letta powers research demos of long-running autonomous agents that need memory management as part of the trajectory
3Zep is the go-to choice for compliance-aware support agents needing to recall the state of a user account at a specific date
4LangGraph state with PostgresSaver is the default working-memory pattern across 2026 LangChain production deployments
5LangChain ConversationSummaryBufferMemory remains common in customer-support chatbots where simple recency is enough
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow would you combine LangGraph state with Mem0 in a production agent?
Sign in or go Pro to see the approach for this follow-up.
QWhen is the temporal model in Zep worth the additional graph-engine complexity?
Sign in or go Pro to see the approach for this follow-up.
QWhy has the MemGPT paging metaphor influenced design beyond Letta itself?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Treating all memory frameworks as variants of the same vector store plus retrieval pattern, missing that they differ in who manages eviction, how time is modeled, and where the model fits in the loop.