Letta and Supermemory represent two distinct philosophies for adding long-term memory to AI agents. Letta (formerly MemGPT) gives agents autonomous control over their own memory tiers, while Supermemory focuses on high-accuracy hybrid RAG with bui...
Letta and Supermemory represent two distinct philosophies for adding long-term memory to AI agents. Letta (formerly MemGPT) gives agents autonomous control over their own memory tiers, while Supermemory focuses on high-accuracy hybrid RAG with built-in connectors for productivity tools.
This comparison covers their architectures, benchmark performance, pricing, and ideal use cases to help you decide.
| Factor | Letta | Supermemory |
|---|---|---|
| Architecture | Three-tier self-editing memory | Hybrid RAG with fact extraction |
| LongMemEval* | Not published | 85.2% |
| Deployment | Self-hosted (Docker/Python) or Letta Cloud | Cloud API only |
| Pricing | Open source / Cloud TBD | Not publicly disclosed |
| GitHub Stars | 22K | 21.7K |
| Funding | $10M seed (YC, Jeff Dean) | $2.6M seed (Google/Cloudflare execs) |
Letta (formerly MemGPT) pioneered the concept of agents that manage their own memory through function calls. Born from UC Berkeley research, the agent decides what's worth remembering and can edit its own memory across three tiers: core, recall, and archival.
With 22K GitHub stars and $10M in seed funding (including Jeff Dean as an investor), Letta has strong research credentials and an active community.
Key strengths:
Supermemory uses a hybrid RAG approach combining vector search with LLM-based fact extraction. Founded by a 19-year-old and backed by $2.6M from Google and Cloudflare executives, it achieves 85.2% on LongMemEval and includes connectors for Google Drive, Gmail, Notion, OneDrive, and GitHub.
Supermemory positions itself as a multi-modal memory engine, handling PDFs, images (OCR), videos (transcription), and code alongside conversational memory.
Key strengths:
Letta gives the agent control over memory management through function calls across three tiers:
The agent decides what moves between tiers. This creates autonomous memory management—the LLM itself determines what's important enough to persist and when to retrieve it.
Supermemory combines vector search with structured fact extraction. The memory engine processes conversations to extract facts, handles temporal changes and contradictions, and builds user profiles with ~50ms retrieval latency.
It also integrates with external data sources (Google Drive, Notion, GitHub), making it a broader knowledge layer rather than just a conversation memory.
Letta delegates memory decisions to the agent; Supermemory handles memory extraction automatically.
When a user mentions their job in conversation, Letta's agent must decide to call a memory function and choose which tier to store it in. If the agent doesn't call the function, the information is lost when it scrolls out of the context window.
Supermemory automatically extracts the fact and stores it—no agent decision required. The tradeoff is that Supermemory's extraction is a black box, while Letta's memory operations are explicit and inspectable.
This difference in philosophy—autonomous vs. automatic—defines which use cases each tool serves best.
| Benchmark | Letta | Supermemory |
|---|---|---|
| LongMemEval* | Not published | 85.2% |
Letta has not published LongMemEval scores, instead maintaining its own Letta Leaderboard. This makes direct comparison difficult. Supermemory's 85.2% places it in the upper tier of published benchmarks.
Both score below Hypabase (87.4%), which uses AMR-based extraction for higher retrieval accuracy.
| Tier | Price | Details |
|---|---|---|
| Open Source | Free | Self-hosted via Docker or Python |
| Letta Cloud | TBD | Managed hosting, pricing not finalized |
| Tier | Price | Details |
|---|---|---|
| Cloud API | Not publicly disclosed | Contact for pricing |
Neither tool has transparent, published pricing for their cloud offerings. Letta has the advantage of a fully open-source self-hosting option, while Supermemory is cloud-only with no self-hosted path.
For teams evaluating cost: Letta's open-source option means infrastructure costs only (your compute + any LLM API calls). Supermemory's pricing requires direct contact with their team.
Choose Letta if you:
Letta's agent-controlled memory is powerful for autonomous agent workflows, though the lack of published retrieval benchmarks makes accuracy hard to evaluate against alternatives.
Choose Supermemory if you:
Supermemory's 85.2% LongMemEval score is solid, though its cloud-only deployment and undisclosed pricing may limit teams that need cost transparency or data sovereignty.
Neither Letta nor Supermemory solves the extraction problem cleanly. Letta's UC Berkeley-rooted agent must choose the right function call at the right time—miss one, and context is gone. Supermemory's black-box extraction gives you no visibility into what was captured or lost. Both rely on ad-hoc LLM prompts that fragment multi-role facts into disconnected triples.
Hypabase takes a fundamentally different path: AMR-based extraction into hyperedges.
| Factor | Letta | Supermemory | Hypabase |
|---|---|---|---|
| Extraction | Agent-controlled function calls | LLM-based, automatic | AMR (formal linguistic framework) |
| Representation | Three memory tiers | Vector + facts | N-ary hyperedges |
| LongMemEval* | Not published | 85.2% | 87.4% |
| Personalization | — | — | 100% |
Hypabase uses Abstract Meaning Representation (AMR)—a formal framework from computational linguistics—to map sentences into structured graphs. Instead of ad-hoc LLM prompts, AMR produces dense, multi-role facts in PENMAN notation using karaka semantic roles (from Panini's Sanskrit grammar):
"Frank prefers VS Code with vim keybindings for Go development"
Ad-hoc extraction (Letta, Supermemory):
(Frank, prefers, VS Code)
(Frank, uses, vim keybindings)
(Frank, develops_in, Go)
AMR extraction (Hypabase):
(prefers :agent Frank :object VS-Code :instrument vim-keybindings :locus Go-development)
The difference: one hyperedge with four semantic roles vs three disconnected triples. When you later ask "What editor setup does Frank use for Go?", the hyperedge returns the complete picture—editor, keybindings, and language—in one atomic retrieval. The triple-based systems require reassembling fragments and hoping nothing was lost.
| Benefit | How It Works |
|---|---|
| No invisible extraction failures | PENMAN has defined grammar—malformed extractions are caught at parse time, unlike black-box LLM extraction |
| Precise role-based queries | Query :agent Frank + prefers to find all of Frank's preferences, regardless of how you phrase the question |
| Preferences that actually stick | 100% personalization accuracy because user preferences are stored structurally, not as semantic approximations |
| Single SQLite file | No Docker orchestration, no cloud-only lockout—runs anywhere your agent runs |
They solve different problems. Letta gives agents autonomous memory control but hasn't published retrieval benchmarks. Supermemory achieves 85.2% with automatic extraction and multi-modal support. For higher accuracy with structured extraction, consider Hypabase (87.4%).
Letta is fully open source and self-hostable via Docker or Python. Supermemory is cloud-only with no self-hosted option. If self-hosting with minimal infrastructure is important, Hypabase runs entirely in a single SQLite file with no external database required.
Letta delegates memory decisions to the agent (autonomous control). Supermemory handles extraction automatically (no agent involvement). Hypabase uses AMR for structured extraction into hyperedges, combining automatic extraction with formal linguistic precision.
Letta has a dedicated coding agent product (Letta Code) with memory tailored for development workflows. Supermemory doesn't specifically target coding use cases. Hypabase's MCP server integrates directly with Claude Code and Cursor for coding-focused memory.
Letta offers agent-controlled memory management with strong research backing, but the lack of published LongMemEval scores makes retrieval accuracy difficult to evaluate.
Supermemory achieves 85.2% with automatic extraction and multi-modal connectors, though cloud-only deployment and undisclosed pricing limit some teams.
Hypabase achieves 87.4% through AMR-based extraction into hyperedges—structured knowledge representation that preserves relationships ad-hoc extraction fragments. 100% on personalization tasks.
All three are straightforward to integrate:
LongMemEval scores: Supermemory (85.2%) from published benchmarks. Letta has not published LongMemEval scores. Hypabase (87.4%) from published benchmark harness.