iCog vs mem0 vs Letta (MemGPT): choosing an AI memory layer
Three good projects, three different problems. A factual map of the AI-memory category and where each one actually fits.
“AI memory” is one phrase covering several different products. mem0, Letta, and iCog all show up when you search for it, and all three are legitimately good at what they do — but they are not substitutes for one another. Picking the right one starts with being honest about which problem you actually have.
This is a descriptive comparison, not a takedown. Where we have a stake, we say so. mem0 and Letta are well-built projects with real adoption; the point here is fit, not winners.
The category, in one table
| What it is | Primary buyer | You interact with it via | |
|---|---|---|---|
| mem0 | A memory layer / SDK for developers to add persistent memory to their apps and agents | Engineers building an AI product | Python/JS SDK, API, self-host |
| Letta (MemGPT) | A stateful agent framework — agents as long-lived, memory-managing servers | Engineers building autonomous agents | Agent framework, server, ADE |
| iCog | An MCP-native memory layer for the human who uses many AI tools | The person living inside Claude/Cursor/Codex/ChatGPT | Install once via MCP; it attaches to your existing tools |
The key axis is who the buyer is. mem0 and Letta are developer infrastructure — you build something on top of them. iCog is an end-user memory layer — you install it and your existing tools get memory. That single distinction explains most of the differences below.
mem0: the memory SDK for builders
mem0 is, in the most useful sense, a library. You import it, and your application gains a memory store: it extracts salient facts from conversations, embeds them, and retrieves relevant ones on later calls. It has strong open-source traction and is a sensible default if you are an engineer who needs to bolt persistent memory onto a product you are shipping.
What that means in practice:
- Great fit if you are writing the agent and want a clean memory primitive you control in code.
- Less of a fit if you are not a developer, or if your goal is “make the AI tools I already use remember me” — that is not what an SDK is for. You would be building the surrounding product yourself.
mem0 is increasingly reachable over MCP as well, which narrows the gap on the integration axis — but the orientation stays developer-first: it is a component, not a finished memory product for end users.
Letta (MemGPT): stateful agents as a framework
Letta descends from the MemGPT research out of Berkeley, whose core idea is treating the LLM like an operating system that pages information in and out of its limited context — managing what stays “in core” versus what is offloaded to longer-term storage. Letta productizes that into a framework where agents are persistent, stateful servers with explicitly managed memory blocks, plus tooling to build and inspect them.
What that means in practice:
- Great fit if you are building autonomous, long-running agents and want first-class control over how each agent manages its own memory and state.
- Less of a fit if you do not want to author and operate agents at all. Letta’s unit is the agent; if you just want your own memory to follow you across Claude and Cursor, the framework is more machinery than the job needs.
Letta’s strength — fine-grained, programmable agent state — is exactly the thing an end user shouldn’t have to think about.
iCog: an MCP-native memory layer for the person, not the app
iCog starts from a different question. Not “how do I give my agent memory” but “how do I, the human who uses five different AI tools, stop re-explaining myself to each one.”
So the design choices differ:
- MCP-native and cross-tool. iCog installs as an MCP memory server and attaches to the tools you already use. A memory written while coding in your IDE is recalled that evening in a chat client. The memory layer sits underneath your tools rather than inside any one of them.
- A cognitive architecture, not just a vector store. Memories are typed — semantic (facts), episodic (events), procedural (how-tos), and foundational (identity and core preferences). Recall ranks candidates by relevance to your current task, not just raw similarity. And a background “dream” consolidation pass applies decay to stale memories, merges duplicates, reconciles contradictions, and promotes recurring episodic signals into durable semantic knowledge — so the store sharpens as it grows instead of accumulating noise.
- You are the user, not the integrator. There is no agent to author and no app to build around it. You install it and your existing assistants start remembering you.
Where we are biased: iCog is what we build. We think the cross-tool, install-once-for-yourself shape is underserved, because the well-funded part of this market is developer infrastructure (mem0, Letta) and per-vendor walled gardens (ChatGPT/Claude memory), and neither of those owns the “memory that travels with you across every AI” claim.
How to choose
- You are building an AI product and want a memory primitive in your code → mem0.
- You are building autonomous, stateful agents and want to control their memory management → Letta (MemGPT).
- You personally use several AI tools and want one memory that follows you across all of them, with decay, consolidation, and relevance-ranked recall handled for you → iCog.
These are not mutually exclusive worldviews — a team could ship a mem0-backed product and use iCog personally. They simply answer different questions. The mistake is assuming one phrase (“AI memory”) means one product.
For the longer argument about the category — the four player types, the MCP shift, and the gap none of the walled gardens are filling — see our State of AI Memory analysis and the broader writeup at cognitivx.io.