Memory APIs for AI agents: a buyer's guide (April 2026)

Disclosure: I build one of these tools (Smara). I've tried to make this post neutral enough that you'd trust it from someone who didn't. If I've mischaracterized another vendor's feature set or pricing, email me and I'll fix it.

What's actually the same

Before the differences, the stuff they all do:

Store text "memories" tied to a user or entity, optionally with metadata.
Embed memories into a vector store for semantic recall.
Return relevant memories on query, usually with a relevance score.
Offer SDKs for Python / TypeScript, plus a REST API.
Some form of MCP or plugin integration with Claude Code / Cursor / similar clients.

If you only need that core loop, any of the four will work. The real choices are about who they're built for, how they price, and what operational assumptions they bake in.

The four tools

Mem0 Pro · $249/mo

Positioning: "The memory layer for AI agents." Large, well-documented, lots of GitHub stars, lots of integrations. Clear leader in mindshare.
Right for: Teams with budget who want the most battle-tested option and value ecosystem size over price.
Tradeoffs: $249/mo is the anchor price for "production" use, which prices out indie devs and early-stage products. Dashboard UX skews toward team workflows.

Zep Flex+ · $475/mo

Positioning: Long-term memory with temporal graph reasoning. Memories don't just sit in a vector store — they connect.
Right for: Conversational agents where relationships between entities matter (e.g. "what did the user say about company X, and how does that relate to what they said about company Y?").
Tradeoffs: Most expensive of the four. Graph reasoning is genuinely useful for some use cases and overhead for others — if you just need "recall relevant past messages," you're paying for machinery you're not using.

Letta Max · $200/mo

Positioning: Agent framework with persistent memory, not purely a memory API. Came out of MemGPT research — the agent-controls-its-own-memory paradigm.
Right for: Building an agent where the agent itself decides what to remember, summarize, and forget. OS-like agents with long-running state.
Tradeoffs: You're buying into a framework, not just an API. If you already have an agent architecture and just need memory as a service, Letta is more than you need.

Smara Developer · $19/mo

Positioning: Memory API for indie devs and small teams building with MCP clients (Claude Code, Cursor, Windsurf). Shared memory across tools via MCP. Ebbinghaus decay — memories fade the less you access them. (This is my tool.)
Right for: Indie devs or small teams using Claude Code or Cursor who want shared context across tools, who want production-ready memory for under $20/mo.
Tradeoffs: Younger product. Smaller community. No knowledge graph reasoning (just vector + decay). If your use case needs relationship reasoning across entities, Zep is the better fit.

Feature parity table

	Mem0 Pro	Zep Flex+	Letta Max	Smara Developer
Price/mo	$249	$475	$200	$19
Free tier	Yes (limited)	Yes (meaningful)	Yes	Yes (10K memories)
Vector recall	✓	✓	✓	✓
Memory decay	—	✓ (graph)	✓ (agent-led)	✓ (Ebbinghaus)
Graph reasoning	—	✓	Partial	—
MCP integration	Via community	Via community	Via community	Native (7 tools)
Tool-agnostic shared memory	—	—	—	✓
Self-host option	✓ OSS	✓ OSS	✓ OSS	— (hosted only)

Notes on the table:

"Tool-agnostic shared memory" means one API key shared across Claude Code, Cursor, Windsurf, etc. Mem0/Zep/Letta can be wired up per-client but it's your integration work. Smara ships this as the core product.
Mem0, Zep, Letta all have self-hostable OSS versions. The $200–475/mo pricing is for their managed cloud — you can run the OSS for the cost of your own infra. Real option if you have ops capacity.
Smara is hosted-only right now. If you need self-hosted memory, Mem0 OSS is probably your starting point.

The price gap question

You're reading this table and thinking: how is there a 25× price gap between Smara and Zep for tools that look similar on paper?

Three honest reasons:

Buyer segment. Zep and Mem0 price for mid-market and enterprise teams with procurement processes. Smara prices for the individual developer paying out of pocket. Same capacity classes cost different amounts in different buyer segments — this is true for every SaaS category, not memory-specific.
Feature depth. Zep's graph reasoning is real engineering and it's expensive to run. If you don't need it, you're paying for it anyway on their platform. Smara explicitly doesn't build that tier of feature, so the cost structure doesn't demand the pricing.
Market-making. Smara is younger and is buying market share with lower pricing. This will probably move up over time as the product matures. Today's $19 is a window, not a promise that it stays there forever.

So: if your use case needs graph reasoning or you want a fully self-hosted deployment, the price gap isn't real — you're buying different things. If your use case is "give my coding agents persistent context and let them share it across tools," the gap is real and you should pay attention to it.

Decision framework

Use Mem0 if

You want the biggest ecosystem and community.
Your team's budget absorbs $249/mo without blinking.
You're OK doing MCP integration yourself.

Use Zep if

Your agent needs to reason about relationships between entities.
You have the budget for Flex+ or higher.
Graph-shaped memory fits your domain (CRM-like, research-like, social-network-like).

Use Letta if

You're building an agent-OS-style application where the agent controls its own memory.
You want an agent framework, not just a memory API.
The free or mid-tier meets your needs while you evaluate.

Use Smara if

You're an indie dev or small team building with Claude Code, Cursor, or other MCP clients.
You want shared memory across coding tools without writing glue code.
You value simplicity and price over enterprise-grade features.
You're OK with hosted-only (no self-host yet).

Use none of the above and build your own if

You're already running Postgres with pgvector and memory is trivial in your architecture.
You have unusual requirements (on-prem, specific compliance) that don't map to any vendor.
You genuinely want the learning experience of building the memory layer yourself.

What I'd do

If I were starting a new coding-agent project today and didn't already work on Smara, my actual decision tree would be:

Prototyping or personal project: use the free tier of whoever has the best docs. Mem0 has the most material. Free tiers are all meaningfully usable for learning.
Shipping to a few real users: $19/mo Smara if you're MCP-based, or Mem0 Starter tier otherwise. Low stakes, easy to swap out later.
Production at scale with budget: Mem0 Pro or Zep, depending on whether you need graph reasoning. Letta if you're building an agent framework.
Enterprise with compliance requirements: self-host Mem0 OSS or Zep OSS, depending on your infra capacity.

That's the actual map. Most posts in this category try to be exhaustive; a buyer's guide should just tell you which tool to pick for your situation.

Last word

The memory-for-AI space is still shaping itself — pricing, features, and positioning are all going to move in the next year. Don't over-commit to any of these vendors. Pick the cheapest tool that meets your current needs, design your data layer so you can migrate later, and revisit in six months.

If you're in the Smara target segment and want to try it, smara.io has a free tier and a $19/mo Developer plan. If you land on Mem0, Zep, or Letta instead, that's fine — better to use the right tool for your situation than the one the author happens to sell.