Match each 2026 memory framework to its core abstraction

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.