Best Memory Tools for AI Agents
The best memory tool for most AI agents is Mem0: a dedicated memory API with a permanently free tier — 10,000 memory add requests and 1,000 retrieval requests a month, no credit card — and paid plans from $19/month. Zep builds a temporal knowledge graph instead of a flat fact list, and charges only for what you ingest; LangMem is the free-library option for LangGraph users who would rather run memory themselves. Every figure below was read on the vendor's official pricing or documentation page.
Last checked: October 2026 · Researched from official documentation — hands-on API tests rolling out (methodology)
- Best overall Mem0
- Best knowledge graph Zep
- Best usage-based pricing Supermemory
- Best for LangGraph LangMem
| # | Tool | What it is | Starting price (as published) | Free tier | Notable strength / limit |
|---|---|---|---|---|---|
| 1 | Mem0 | Managed memory layer that extracts facts from conversations and retrieves them per user, session, or agent — plus an Apache 2.0 open-source version you can self-host. | Starter $19/mo (50,000 add requests, 5,000 retrieval requests, 1 project). Pro $249/mo (500,000 adds, 50,000 retrievals, unlimited projects, graph memory). Enterprise custom (on-prem, SSO, audit logs, SLA) | Yes — permanently free Hobby plan: 10,000 add requests + 1,000 retrieval requests/month, 1 project, no credit card required | Two separate meters — and retrieval is the tight one (1,000/month free, 5,000 on the $19 plan) for chatty agents. Graph memory (entity linking) is gated to the $249 Pro tier; the self-hosted open-source version drops the platform meters entirely. |
| 2 | Zep | Context infrastructure that builds a temporal context graph from "Episodes" (chat messages, JSON, text), so agents can reason about facts that change over time. | Flex $125/mo (50,000 credits included, then $25 per 10,000 credits). Flex Plus $375/mo (200,000 credits). Enterprise custom (SOC 2 Type II, HIPAA BAA, VPC/BYOC deployment) | Yes — 10,000 credits/month free, 2 projects; retrieval, storage, and users are unmetered on every plan | You pay only for ingestion: 1 credit per Episode up to 350 bytes (+1 per additional 350 bytes), and retrieval costs 0 credits. The flip side is the steepest paid entry here — $125/month — and SOC 2 / HIPAA are Enterprise-only. |
| 3 | Supermemory | Memory infrastructure with a per-user memory graph, multimodal ingestion (documents, PDFs, audio, video via its SuperRAG layer), and connectors — billed on unique ingested tokens. | Pro $19/mo ($20 of usage credits included). Max $100/mo ($130 credits). Scale $399/mo ($600 credits, advanced PDF extraction, self-hosted option). Rate card on every plan: Memory $5 per 1M tokens (plain text), search $5 per 1M queries | Yes — $0 plan with $5 of credits, renewed every month | The most transparent metering here: only unique content is ever billed — re-ingesting unchanged content is free — and the full rate card is published. The trade-off is doing credit math against "SM tokens" before you can predict a bill, and it is a newer vendor than the two above it. |
| 4 | Letta | Stateful agent platform — the MemGPT lineage — where long-term memory is part of the agent runtime itself (web app, CLI, and API), not a bolt-on memory service. | Pro $20/mo (up to 20 stateful agents, included Letta Auto usage quota, pay-as-you-go overage). Developer plans are usage-based credits with unlimited agents; server-side tool execution is billed at $0.00015/sec on the API plan | Yes — free plan with bring-your-own API keys, limited to 3 stateful agents | Memory is architectural: agents manage their own memory and state across sessions by design. But you adopt Letta's agent runtime to get it — it won't drop into an existing LangChain/CrewAI stack the way the APIs above do. Per-model credit rates are published in Letta's platform dashboard rather than on its pricing page. |
| 5 | LangMem | LangChain's open-source Python SDK: memory tools agents call mid-conversation, plus a background manager that extracts and consolidates knowledge. Works with any storage; native to LangGraph's long-term memory store. | No hosted product and no pricing page — install the library (pip install langmem) and pay your own LLM API keys and database. Included by default in LangGraph Platform deployments, per its docs |
Yes — the library itself is free; your costs are your own LLM calls and storage | Zero vendor meter and total control over what gets stored and where. You also own everything a hosted API does for you: extraction quality, storage operations, and scaling. It only makes sense if you are already on — or deliberately adopting — LangGraph. |
Verdicts
1. Mem0 Best overall
The default choice for bolting memory onto an agent you already have: a purpose-built API, the most generous hosted free tier in this category (10,000 adds and 1,000 retrievals a month, permanently, no card), a $19 Starter that covers most early production apps, and an Apache 2.0 open-source version as an escape hatch from platform pricing. Watch the retrieval meter — it is sized for considered lookups, not for searching memory on every token — and note that graph memory waits at the $249 Pro tier.
2. Zep Best knowledge graph
The deepest memory model here: instead of a flat list of facts, Zep builds a temporal graph from everything you send it, so "the user's address" can have a history, not just a current value. Its credit model is unusually honest — ingestion is metered by Episode size, retrieval and storage are free — and the free plan's 10,000 credits a month is enough to evaluate it for real. The $125/month Flex entry is the highest in this category, so it ranks second for this audience despite the stronger model; enterprises get SOC 2 Type II and HIPAA options at the top tier.
3. Supermemory Best usage-based pricing
The metering innovator: plans from $19/month are mostly bundles of usage credits, the rate card is identical on every plan ($5 per 1M tokens of plain-text memory; $1–$2 per 1M for its SuperRAG ingestion), and unchanged content is never billed twice. Multimodal ingestion — PDFs, audio, video — is native rather than an add-on, and self-hosting appears at the $399 Scale tier with SOC 2 and HIPAA BAA. Ranked third on track record, not on model: it is the newest vendor on this page.
4. Letta Best stateful-agent platform
A different animal: Letta (formerly MemGPT) is an agent platform whose agents are stateful by construction — memory blocks, archival memory, and self-editing context are the runtime, not a plugin. The free tier with your own keys covers 3 stateful agents, Pro at $20/month covers 20, and developer plans switch to pure usage credits with unlimited agents. Choose it when you are picking an agent framework anyway; if you already have a stack, the three APIs above it will fit with far less surgery.
5. LangMem Best for LangGraph
LangChain's answer to memory is a library, not a service: hot-path tools your agent calls to record and search memories, a background manager that consolidates them, and storage you choose — including LangGraph's own long-term store, where it is available by default. There is nothing to buy and no meter to watch, which is exactly right for LangGraph teams with platform skills — and exactly wrong for anyone hoping memory is a solved API call away.
Frequently asked questions
What is the best memory tool for AI agents?
For most builders, Mem0 — a dedicated memory API, free up to 10,000 adds and 1,000 retrievals a month, $19/month to start paying, and an open-source version if you outgrow hosted pricing. Zep when facts need a temporal graph; LangMem when you are on LangGraph and want a free library.
How much does memory for AI agents cost?
It depends on the meter. Mem0 meters requests (free → $19 → $249/month). Zep meters ingestion only — credits per Episode, retrieval free — from $125/month after a 10,000-credit free plan. Supermemory meters unique ingested tokens ($5 per 1M, plain text) with plans from $19/month. Letta prices the runtime ($20/month Pro; usage credits for developers). LangMem is free — you pay your own LLM and database bills.
Which memory tool has the best free tier?
Mem0's hosted free tier: 10,000 memory adds and 1,000 retrievals every month, permanently, no credit card. Zep's free plan (10,000 ingestion credits/month, retrieval unmetered) is a close second. Supermemory renews $5 of credits monthly. LangMem costs nothing but your infrastructure.
Memory API or build it myself — which should I choose?
Hosted APIs (Mem0, Zep, Supermemory) handle fact extraction, consolidation, and retrieval for a metered fee — fastest to ship. Libraries (LangMem) and open-source Mem0 give you primitives and control at infrastructure cost. Letta splits the difference by making memory part of an agent platform you adopt wholesale.
Can I self-host agent memory?
Yes: Mem0's open-source version (Apache 2.0) is built for it, LangMem runs in your stack by design, Supermemory offers self-hosting on Scale and Enterprise, and Zep offers VPC/BYOC deployment at Enterprise. Managed-only extras — hosted analytics, managed graph consolidation — stay behind the paid cloud tiers.
Sources (official pages, checked October 14, 2026): mem0.ai/pricing · getzep.com/pricing · supermemory.ai/pricing · letta.com/pricing · langchain-ai.github.io/langmem (official LangMem documentation). Letta's per-model credit rates are published in its platform dashboard, not on its pricing page, and are therefore not quoted here. No third-party sources were used for any figure on this page.