If you've built anything with an AI agent or chatbot, you've hit the same wall: it forgets everything the moment the conversation ends. Ask it about a decision you made yesterday, and it has no idea what you're talking about. That's not a bug — most large language models are stateless by design. Every new session starts from a blank page.
"Agent memory" tools fix this by giving your agent a place to store facts, preferences, and past events, then pull the right ones back out when they're needed. Some are hosted APIs you plug into a product. Others are self-hosted frameworks, or small local tools built specifically for AI coding assistants like Claude Code and Cursor. Below are six real, currently available options — what each one is actually good at, what it costs, and where it falls short.
The short version
| Tool | Best for | Pricing |
|---|---|---|
| Mem0 | General-purpose managed memory API, fastest to adopt | Free tier, then $19–$249/mo |
| Zep | Enterprise agents that reason over facts that change over time | Free tier, then $104–$312/mo |
| Letta | Full self-hosted control, built on MemGPT research | Free tier, then from $20/mo |
| Statewave | Compliance-heavy production agents needing audit trails | Free, open source |
| AgentMemory | Local memory for coding assistants (Claude Code, Cursor) | Free, open source |
| PMB | Same niche as AgentMemory, zero-telemetry local recall | Free, open source |
Mem0 — the default pick for most teams
Mem0 gives AI chatbots and agents a real memory so they remember what you told them last week, instead of forgetting everything the moment a conversation ends. It's the most adopted tool in this space by a clear margin — over 61,000 GitHub stars — and it's the memory provider built into the AWS Agent SDK, which is about as strong a third-party validation as this category gets. It combines vector, graph, and episodic memory in a single product, and it's SOC 2 Type 1 and HIPAA compliant.
Pricing: Hobby tier is free (10K add requests/month). Starter is $19/month for 50K requests, Pro is $249/month for 500K requests plus graph memory, and Enterprise is quote-based for on-prem/SSO/SLA needs.
Where it falls short: Mem0 is a generalist rather than a specialist — Zep goes deeper on temporal reasoning, and Letta gives you more control if you want to self-host completely. The Pro tier is worth checking carefully against your real traffic if you lean heavily on graph memory.
Zep — for facts that change over time
Zep builds a living map of everything a user has told an agent over time, and how those facts connect and change, so the agent can pull the right context in under 200ms instead of re-reading an entire chat history. It's aimed squarely at enterprise teams in regulated industries that need an agent to reason about facts that evolve — not just retrieve similar-sounding text.
Pricing: Free tier gives 10,000 credits/month across 2 projects. Flex is $104/month (billed annually) for 50,000 credits, Flex Plus is $312/month for 200,000 credits, and Enterprise is quote-based.
Where it falls short: Zep is more specialized and less broadly adopted than Mem0 (around 4,770 GitHub stars), and that temporal-graph approach can be more complexity than you need for a simple memory use case. The free tier's 10K credits also burn through fast in serious testing.
Letta — for full self-hosted control
Letta is an open-source framework for building AI agents that keep their state and memory under your own control — self-hostable, and built on real academic research (MemGPT, out of UC Berkeley) rather than being a pure marketing product. It's Apache 2.0 licensed with 24,000+ GitHub stars, and Letta Code ranked #1 on the independent Terminal-Bench benchmark.
Pricing: Free tier gives you 3 stateful agents with bring-your-own API keys. Personal Pro is $20/month for 20 agents with a remote sandbox, Developer API is $20/month plus $0.10 per active agent/month plus LLM usage costs, and Teams Pro is $20/seat/month.
Where it falls short: Letta is a framework to build on rather than a plug-and-play API like Mem0 — you're trading setup time for control. The per-active-agent pricing also needs careful modeling once you're running many agents at scale.
Statewave — for compliance and auditability
Statewave is a free, open-source memory system for AI agents that remembers things the same reproducible way every time, instead of memory that shifts slightly on every search — which makes an agent's behavior hard to trust or audit. It's built for teams that need governance baked in from the start: sensitivity labels, HMAC-SHA256-signed receipts, and multi-tenant isolation, all self-hosted on PostgreSQL under an Apache 2.0 license.
Pricing: Completely free — no licensing cost, self-hosted on your own PostgreSQL instance.
Where it falls short: You're operating your own infrastructure (PostgreSQL, Docker), and it's a young project (284 GitHub stars) with less community track record than the established players above. If compliance and audit trails aren't a real requirement for you, it's more machinery than you need.
AgentMemory — local memory for coding agents
AgentMemory is a different flavor of this category: a local notebook for AI coding assistants like Claude Code or Cursor, so they remember what happened in yesterday's session instead of starting from a blank page every time you open a new chat. It runs 100% locally with zero external database dependency, using hybrid search (BM25 + vectors + graph) to keep retrieval latency low.
Pricing: Free and open source (Apache 2.0).
Where it falls short: Performance numbers are self-reported and not independently verified, it's a young project without a company or public track record behind it, and there's no native multi-device sync — you configure memory per agent rather than getting zero-config setup.
PMB — the zero-telemetry alternative to AgentMemory
PMB covers the same ground as AgentMemory: it's a free tool that gives AI coding assistants like Claude Code or Cursor a real memory, so you stop re-explaining the same project decisions every session. It supports Claude Code, Cursor, Codex, and Zed via MCP, uses the same hybrid BM25 + vector + entity-graph recall approach, claims a 94.6% recall@10, and automatically decays memories that stop being used.
Pricing: 100% free, Apache 2.0, no telemetry, no API key required.
Where it falls short: Like AgentMemory, there's no native cloud sync or team sharing, and as a newer open-source project it comes with fewer guarantees than a managed service.
Which one should you actually use?
If you're adding memory to a product and want the path of least resistance, start with Mem0 — it's the most battle-tested and the easiest to bolt on. If your agent needs to reason about facts that change over time in a regulated setting, Zep is built for exactly that. If you want to own your stack completely, Letta gives you a self-hosted framework with real research behind it, and Statewave is the pick when auditability is a hard requirement, not a nice-to-have. And if the problem you actually have is "my coding assistant forgets everything between sessions," skip the hosted APIs entirely and reach for AgentMemory or PMB — both are free, local, and purpose-built for that exact job.