Mem0 vs Letta vs Zep vs Uteke: Cloud Memory Layers vs the Offline Engine

Every agent memory comparison this year reads like a cloud pricing page. Mem0, Letta, and Zep are good products with real differences, and their managed platforms deserve the attention they get. But the first question that decides most deployments never gets asked: where does the memory live, and does it work when the network is not part of the picture?

This post puts the three platforms the market talks about next to Uteke, our offline memory engine, and compares them honestly. That includes the trade-offs we chose and the features we gave up to get them.

The three platforms the market talks about

Mem0 is an extraction layer. It watches conversations, distills them into discrete facts, and stores those in a vector store your agent queries per turn. You bolt it onto an existing agent with a few lines of code, which is why it is the default recommendation for per-user personalization. The trade: extraction runs an LLM call on the write path, and the hosted free tier meters storage and retrieval separately (10,000 adds and 1,000 retrievals a month at the time of writing).

Letta, the productized continuation of the MemGPT research, treats memory as part of the agent runtime. The agent holds editable memory blocks and decides what to keep resident through its own tool calls. It is the most coherent model if you want the agent to own its memory, and the heaviest to operate: a Letta deployment brings a Postgres database and a server process with it.

Zep builds a temporal knowledge graph on its open Graphiti engine. Every fact is an edge with a validity window, so "which plan was this account on last quarter" resolves correctly instead of returning both answers. For CRM-style state where facts change, nothing else in this comparison models the problem as well. The cost is machinery: a graph database, extraction on the write path, and more context injected per turn.

The fourth option: an engine that lives on your disk

Uteke takes the opposite bet. It is a single Rust binary that stores memories in one SQLite file on your machine, computes embeddings locally on CPU, and recalls in around 45ms with no network call anywhere in the path. There are no API keys, no usage meters, and no vendor account. Version 0.17.0 shipped on September 6, 2026, the project is Apache 2.0 licensed, and it runs in MCP server mode, so Claude Code, Cursor, and any MCP client can use it as memory.

The bet is that a large share of agent memory needs are single-operator: one developer, one machine, one agent stack. For that share, shipping memory to someone else's datacenter adds a dependency without adding a capability.

The comparison table

Where each one wins

Pick Zep when your questions are temporal. If the agent needs to answer "what changed when" about entities that evolve, the validity-window model is the right one and the graph machinery pays for itself.

Pick Mem0 when you have a working agent and want memory bolted on with minimum friction. The hosted API is the smooth path, and per-user personalization is exactly what the extraction model was built for.

Pick Letta when you are starting fresh and want memory and runtime as one system. The agent editing its own memory blocks is a genuinely different design, and rebuilding around it only makes sense before you have an agent to keep.

Pick Uteke when the memory should live on your hardware. Laptops without reliable connectivity, machines holding sensitive data, home labs, air-gapped environments, and anyone tired of usage meters on a recall query. The honest limits: there is no temporal graph, no hosted multi-tenant dashboard, and the scope is one operator, not a team syncing shared state. If you need those, the cloud platforms are the better fit and this is the wrong post to pretend otherwise.

Three questions that decide it

Before comparing feature matrices, answer these. One: does this memory data need to leave the machine it is used on? Two: does recall have to work without a vendor endpoint reachable? Three: what does a memory write cost at your volume, counting the LLM call extraction requires? The first two questions eliminate candidates faster than any benchmark, and the third one scales badly on cloud tiers exactly when your agent starts working.

Frequently asked questions

Is Uteke a replacement for Mem0?

For the single-operator, local-first case, yes in practice: you get persistent semantic recall without the metered API. For hosted multi-user products that need extraction pipelines and a managed dashboard, Mem0 is the more complete platform. Different scope, different bet.

Does Uteke work with Claude Code and Cursor?

Yes. Uteke ships an MCP server mode, so any MCP client can store and recall memories against the local engine. We wrote a separate post on running it as an MCP memory server on local SQLite.

How fast is recall?

Around 45ms for semantic recall on CPU, no GPU required. We published the benchmark methodology and, more importantly, the script to audit it on your own machine.

What does Uteke cost?

Nothing. The whole engine is Apache 2.0, with no paid tier and no usage limits, because the meter is the thing we are arguing against.

Try it

The one-line install:

curl -sSL codecora.dev/uteke/install | sh

Uteke is on GitHub with 240 stars and full docs at codecora.dev/uteke. If you run the comparison yourself against a cloud memory layer, tell us what you found, including when the cloud option won.