Letta vs Mem0 in 2026: Semantic and Episodic Memory for Agents

TL;DR — Letta (formerly MemGPT) treats memory like an operating system — core memory always in context, archival memory in a vector store, recall memory for full conversation history. Mem0 ships a thin API: add() and search(), with hybrid vector-plus-graph retrieval underneath. The 2026 winner is not either tool but the combination — episodic buffer, semantic facts, and graph relations, each handling what it does best.

The technique

Three memory scopes have become standard in 2026:

• Episodic — specific past interactions ("user called yesterday at 4pm about a refund")
• Semantic — facts and preferences ("user is allergic to penicillin," "user prefers Spanish")
• Procedural — learned behaviors and rules ("when user mentions chest pain, escalate immediately")

Letta enforces this through tiers: core memory (small, always in context, like RAM), archival memory (vector store, like disk), recall memory (full history, retrievable on demand). Mem0 enforces it through a flat API but routes internally to vector + graph + relational stores.

flowchart LR
  T[Conversation turn] --> EX[Extractor]
  EX --> EP[Episodic store]
  EX --> SE[Semantic store]
  EX --> PR[Procedural rules]
  Q[Query] --> R{Router}
  R -->|recent| EP
  R -->|fact| SE
  R -->|rule| PR
  EP --> A[Agent]
  SE --> A
  PR --> A

How it works

Letta: every agent runs with a fixed-size core memory block ("user persona", "task state"). When core fills, the agent itself decides what to demote to archival. Archival memory is a vector store; recall memory is full conversation history. The agent can call memory_insert, memory_replace, archival_memory_search as tools.

Mem0: mem0.add(messages, user_id="u1") takes a list of messages, runs an internal LLM extractor, and stores facts as embeddings + graph nodes/edges. mem0.search(query, user_id="u1") returns ranked facts. Hybrid vector + graph retrieval is the under-the-hood default.

The 2026 production pattern is a small stack: vector memory for fuzzy recall, episodic buffer for short-term coherence (last 6–10 turns), graph for entity-heavy queries.

CallSphere implementation

CallSphere agents run a three-layer memory:

1. Session buffer — last 10 turns, kept in agent context (200ms cost).
2. Mem0-style semantic store — facts extracted per call, retrieved by user_id at session start.
3. Neo4j graph layer — for cross-entity questions ("which providers has this patient seen in network?").

The Healthcare agent uses semantic memory for allergies, preferred pharmacy, current medications. UrackIT IT helpdesk uses episodic memory for recent ticket subjects ("the same error as Tuesday"). OneRoof real estate uses graph memory for buyer-broker-listing relationships.

Explore a live demo and compare current plans to find the right fit for your business.

Build steps with code

# Mem0 quick start
from mem0 import Memory
m = Memory()

# Write
m.add("User is allergic to penicillin", user_id="patient_4421")
m.add("User prefers Spanish for clinical conversations", user_id="patient_4421")

# Read at session start
facts = m.search("medication allergy", user_id="patient_4421")

# Letta agent with archival
from letta import create_client, AgentState
client = create_client()
agent = client.create_agent(
    name="healthcare-receptionist",
    persona="You are a HIPAA-compliant medical front desk agent.",
    human="Patient ID 4421, Spanish-preferred, penicillin allergy",
    tools=["archival_memory_insert", "archival_memory_search"],
)

1. Pick one canonical store per memory type — do not duplicate facts across vector and graph.
2. Always include the session buffer; it cuts retrieval calls by 60%.
3. Never let the agent decide on its own to forget; route through TTL/decay.
4. Per-user isolation is non-negotiable for HIPAA / PII.

Pitfalls

• Memory leaking across users: a single shared collection without user_id filter is a HIPAA breach waiting to happen.
• Over-extraction: extractor pulls "user is annoyed" as a permanent fact. Calibrate the extractor.
• No deduplication: 14 copies of "user prefers email" pollute retrieval. Dedupe on insert.
• Stale procedural rules: a rule from last quarter contradicts current policy. Version rules with effective_date.

FAQ

Letta or Mem0? Letta if you want OS-style tiers and self-editing memory. Mem0 if you want one API and graph + vector hybrid out of the box.

Need a graph layer? Yes for entity-heavy verticals (real estate, healthcare). Optional for casual chat.

Self-host? Both have open-source cores. Letta has a hosted plan; Mem0 also has hosted.

Cost? Mem0 hosted starts free for hobby; Letta hosted starts at team-tier pricing.

See it on /demo? Yes — return tomorrow as the same user and notice the agent remembers.

Sources

• State of AI Agent Memory 2026 - Mem0
• Mem0 vs Letta MemGPT Compared 2026 - Vectorize
• Best AI Agent Memory Frameworks 2026 - Atlan
• Letta GitHub
• AI Agent Memory Systems 2026 - HermesOS