What is the difference between LLMWiki, Mem0, and Letta?

They solve different layers of AI knowledge. LLMWiki is a pattern (popularized by Andrej Karpathy in April 2026) for letting an LLM maintain a Markdown wiki as compiled long-term knowledge. Mem0 is a managed service for chatbot conversation memory using vector + graph storage. Letta (formerly MemGPT) is an open-source framework for tiered agent memory that can self-edit. They are complementary — a production agent in 2026 typically uses all three.

Which one should I use for a chatbot?

Mem0. It is the lowest-friction option for chatbot personalization — store user preferences, past conversations, and facts. 48K+ GitHub stars and a managed service that handles infrastructure. For a simple 'remember the user' workflow, Mem0 is the default in April 2026.

Which one should I use for long-running agents?

Letta — formerly MemGPT — has the strongest tiered memory architecture for agents that need to operate independently for hours or days. Self-editing memory and recall mechanisms designed for long horizons. For a research agent that runs overnight or a customer-service agent that maintains state across weeks, Letta wins.

Which one should I use for personal knowledge management?

LLMWiki. Karpathy's pattern is built for the 'I keep generating text I'll never read' problem — agent session transcripts, research notes, meeting transcripts. The output is a human-readable Markdown wiki you can also read yourself. Mem0 and Letta are for agent memory, not human knowledge bases. For PKM, LLMWiki implementations like lucasastorian/llmwiki or Pratiyush/llm-wiki are the right tools.

Quick Answer

LLMWiki vs Mem0 vs Letta: AI Memory Compared (April 2026)

Published: April 30, 2026

LLMWiki vs Mem0 vs Letta: AI Memory Compared (April 2026)

AI memory got crowded in 2026. With Karpathy’s LLMWiki pattern dropping April 28, the field now has four serious contenders for “where does the agent’s brain live.” Here’s how they actually differ and which to pick.

Last verified: April 30, 2026

TL;DR

Use case	Pick
Chatbot personalization	Mem0
Long-running autonomous agent	Letta
Personal/team knowledge base	LLMWiki
Time-aware enterprise memory	Zep
Coding-agent session compaction	LLMWiki
Production stack	All four (different layers)

The lineup

	LLMWiki	Mem0	Letta	Zep
Type	Pattern + OSS impls	Managed service + OSS	OSS framework	Managed service
Storage	Markdown files	Vector + graph	Tiered (working/recall/archival)	Vector + graph (temporal)
Originator	Andrej Karpathy (Apr 2026 gist)	mem0.ai	UC Berkeley (MemGPT)	getzep.com
License	Public-domain pattern; impls vary	Apache 2.0 (OSS)	Apache 2.0	Closed (cloud); OSS Community
Best at	Compiled knowledge	Chatbot memory	Long-horizon agents	Time-aware enterprise
GitHub stars (Apr 2026)	<100 each (new)	48K+	16K+ (as Letta)	3K+
Human-readable output	✅ Markdown	❌ Embeddings	❌ Internal	❌ Internal

What each one is actually for

LLMWiki — compiled knowledge

Karpathy’s pattern, popularized April 28, 2026. The LLM acts as a librarian for a Markdown wiki. Raw sources (agent transcripts, papers, notes) go in; structured wiki pages come out. Future agents read the wiki, not the raw sources.

Where it shines:

Personal knowledge management.
Coding agent session compaction (Claude Code, Codex, Cursor 3 logs become a wiki).
Team knowledge bases that replace abandoned Notion docs.
Agent context bootstrap — new sessions start from compiled knowledge, not raw history.

Where it doesn’t:

Per-conversation user memory in a chatbot.
Sub-second retrieval at scale.
Anything that needs structured queries on time ranges.

Mem0 — chatbot memory

The default for personalization in April 2026. 48K+ GitHub stars, managed service, simple SDK. Stores user facts, preferences, and conversation summaries with hybrid vector + graph retrieval.

Where it shines:

Chatbots that need to remember “the user is vegetarian and lives in Paris.”
Customer support assistants with per-account context.
Personal AI companions where memory of preferences matters.
Lowest-friction managed option — deploy in minutes.

Where it doesn’t:

Agent that needs to plan over weeks.
Cross-user shared knowledge.
Human-readable knowledge base.

Letta — long-horizon agents

The MemGPT lineage, now Letta. Tiered memory architecture inspired by operating systems: working memory (in context), recall memory (paged in/out), archival memory (deep storage). Agents self-edit their memory.

Where it shines:

Agents that operate autonomously for hours or days.
Research agents that build up state across many tool calls.
Customer-service agents that maintain context across weeks of interactions.
Anywhere the agent needs to decide what to remember and what to forget.

Where it doesn’t:

Quick chatbot personalization (overkill).
Human-readable knowledge.
Teams that don’t want to run their own infra.

Zep — time-aware enterprise

Hybrid vector + temporal graph for production. Strong on time-bounded queries (“what did the user ask about in March?”) and enterprise SLAs.

Where it shines:

Enterprise apps with compliance and time-range queries.
Long-running agent sessions where temporal context matters.
Teams that need a managed service with enterprise tier.

Where it doesn’t:

Solo developer projects (heavier than Mem0).
Personal knowledge management.

How they fit together

A serious agentic stack in April 2026 typically uses several of these together:

┌──────────────────────────────────────────────────┐
│  AGENT (Claude Opus 4.7 / GPT-5.5 / Llama 5)     │
└──────────────────────────────────────────────────┘
   │                │                  │           │
   ▼                ▼                  ▼           ▼
┌────────┐     ┌────────┐     ┌──────────────┐  ┌────────┐
│ Mem0   │     │ Letta  │     │ LLMWiki      │  │ RAG    │
│ user   │     │ task   │     │ compiled     │  │ raw    │
│ facts  │     │ state  │     │ knowledge    │  │ docs   │
└────────┘     └────────┘     └──────────────┘  └────────┘

Mem0 holds per-user facts (“Andrew prefers TypeScript”).
Letta holds the agent’s working state across a long task.
LLMWiki holds compiled long-term knowledge (“here’s everything we know about MCP”).
RAG still retrieves raw documents when the wiki doesn’t have an entry.

These are not in competition. They are different layers of memory, like CPU registers vs RAM vs disk vs the internet.

Decision tree

Are you building a chatbot? → Start with Mem0. Add Letta if conversations stretch for hours.

Are you building an autonomous agent? → Start with Letta. Add LLMWiki for cross-session knowledge.

Are you a developer drowning in Claude Code / Codex transcripts? → Use LLMWiki to compile them. Add Mem0 only if you also build a chatbot.

Are you an enterprise with compliance? → Zep for the agent state, LLMWiki for institutional knowledge, Mem0 for customer-facing personalization.

Are you a solo developer experimenting? → LLMWiki + Mem0 covers 90% of needs and both are free to start.

Cost in April 2026

LLMWiki: pattern is free; you pay for the LLM tokens to maintain the wiki. Self-hosted impls are free.
Mem0: free OSS; managed service free tier covers small projects, paid plans from ~$49/month.
Letta: open source, free; you pay for hosting and the LLM.
Zep: managed cloud paid plans, OSS Community Edition free.

For a typical solo or small-team developer in April 2026, the bill is mostly LLM tokens — the memory tooling is essentially free.

Where this is heading

Two trends are reshaping AI memory in 2026:

1. The wiki layer is becoming standard

Karpathy’s LLMWiki pattern is forcing a category that didn’t exist in 2025. Expect Mem0, Letta, and Zep to add native “compiled knowledge” output as a first-class feature within months.

2. MCP is the integration glue

Model Context Protocol gives every memory tool a uniform way to plug into Claude, Cursor, Codex, and the rest. By Q3 2026, expect Mem0, Letta, Zep, and LLMWiki implementations to all expose MCP servers, and pick-and-mix architectures will become the default.

Bottom line

LLMWiki, Mem0, Letta, and Zep are not competitors — they are layers. Pick LLMWiki if you want compiled, human-readable knowledge. Pick Mem0 if you want easy chatbot personalization. Pick Letta if your agents run for a long time. Pick Zep if you have enterprise time-aware needs. In a real production stack, you will probably use more than one.

Built with 🤖 by AI, for AI.