The right Mem0 alternative depends on what your agent keeps forgetting. If it loses facts about a user, a hosted memory API is enough; if it loses how things relate, you want graph memory; if the whole agent needs to persist, look at a stateful agent runtime instead of a memory add-on.
A customer tells your support agent on Monday that they've moved house and the next order should go to the new address. On Thursday they're back, and the agent cheerfully confirms delivery to the old one. Nothing crashed. The model answered from the conversation in front of it, and that conversation started fresh.
Mem0 and its rivals exist to close that gap. But "memory" hides several different jobs, and the costly mistake here is buying a tool built for a job you don't have. So work out which one you're missing first, then look at names.
Decide by what your agent keeps forgetting
Forgetting things about a person is the simplest job in the category. Preferences, a new address, the fact that someone hates being called by their surname: you pull a short statement out of a conversation, store it, and fetch the relevant ones next time. Go for a hosted memory API on a free plan. For a single assistant talking to individual users, you'll rarely need anything heavier, and anything heavier will cost you setup time you won't get back.
When the gap is how things connect, plain recall won't save you. A user's manager approved a budget that funds a project that's now late. Vector search finds text that looks like the question; it doesn't follow a chain of who, what and why. Pick graph or hybrid memory, where entities and the links between them are stored as such. Some tools below blend graph, vector and relational retrieval, which is the safer bet if you're not sure how tangled your data will get.
An agent that doesn't know what the company knows has a context problem, not a memory one. The agent should know what's in Slack, GitHub and Jira, not just what the user said last week. Choose a context layer that syncs your work tools into one searchable store. And if the real problem is answering from a pile of documents, that's retrieval with its own tools: read the RAG tools roundup before you buy a memory product to do a job it'll do badly.
With several agents sharing what they've learnt, the question changes from "does it remember?" to "what should one agent be allowed to know from another?" Look for shared memory with controls on what crosses between agents, ideally kept somewhere a person can open and read.
If you're starting from nothing and the agent itself should persist, skip the add-on. A stateful agent runtime keeps memory, history and learning inside the agent, so you aren't bolting a store onto a stateless loop. It's the heaviest choice on this page and the hardest to walk back, because you're adopting a platform as well as a memory model, so make it on purpose.
One fork cuts across all of those: hosted or your own servers. Hosted services get you working in an afternoon and keep someone else on call. Open-source options keep user data in your own estate, which matters the moment your agent remembers anything you'd rather not hand to a third party. It isn't always either-or: several of the open-source projects below also sell a managed cloud, so you can prototype hosted and move in-house later.
Memory APIs and context services you call
Zep
Aimed at larger companies, this hosted context layer gives agents governed access to business knowledge plus memory built from the tasks they run.
Supermemory
A hosted memory API built around fast recall and connectors, for developers who want agents to keep learning between sessions without running infrastructure.
Graphlit
When the agent needs to know what's in Slack, GitHub and Jira, this context API syncs those sources into one searchable place.
ByteRover
Teams running several agents use this shared memory service to decide which context passes between agents and which stays put.
memU
Memory kept as readable Markdown, shared across coding and personal agents, so a person can open it and see what the agent believes.
Libraries, graph stores and stateful runtimes
Cognee
An open-source agent memory platform mixing graph, vector and relational retrieval, which you can self-host in Docker or run in its cloud.
LangMem
If you already build on LangChain, this library adds tools for pulling out, storing and refining long-term memories.
Hindsight
From the Vectorize team, long-term agent memory that learns across sessions, available to self-run or as a hosted service.
Want AI doing the heavy lifting in your marketing?
I build the systems that handle the boring 80 percent, so you get your week back. Done properly, with the human kept in.
HydraDB
A graph database for agent context that you can run yourself from the open-source code or use as a managed cloud.
Letta
Rather than a memory add-on, a platform for building stateful agents that remember and keep learning as part of how they run.
Break it on purpose before you commit
Feature pages won't tell you how a memory layer copes with what breaks agents in real use: facts that change. So stage a contradiction drill, the same script against your top two or three candidates, in an afternoon.
Invent one user and write five short conversations. In the first, they mention a home city, a favourite product and a job title. In the second, they've been promoted and say so. In the third, they mention the weather, which shouldn't be stored at all. In the fourth, they ask the agent to forget the favourite product. In the fifth, you ask three questions: where do I live, what do I do, and what do I like buying?
A layer worth keeping answers with the new job title, not the old one and not both. It hasn't saved the weather. It's dropped the product when asked. Now open the stored memories and read them yourself. If you can't see or edit what the agent believes about a user, you'll struggle to fix it when a real customer complains, and you'll have no clean way to honour a request to delete their data. Run the drill twice: once saving after every turn and once at the end of the session, because that choice changes both the quality and the bill.
Time the lookup too. Memory sits in front of every reply, so a slow recall step slows every answer your agent gives.
Where the money goes
Compare the billing unit before the number, because these tools don't charge alike. The hosted ones bill by credits, by tokens processed, by a flat monthly plan, or by a plan with usage on top. On the vendors' own pricing pages this month, the hosted services that publish a monthly price start their first paid tier anywhere from under $20 to just under $130 a month, before usage, and enterprise terms are on quote. One graph store sets a monthly usage minimum on its managed cloud; one runtime caps how many stateful agents its free plan allows. The open-source libraries cost nothing to download, and their real price is the database, hosting and engineering time behind them.
Two habits push any memory bill up faster than you'd expect. A layer that extracts facts calls a model to do it, so an agent that saves after every turn costs far more than one that saves once a session. And retrieval runs on every request, so cost tracks traffic rather than how much you've stored. The embedding model behind recall matters too, and the embedding models comparison covers that choice.
Most tools here has a way in that costs nothing: a free plan, open-source code, trial credits or sign-up credit. Use it to run the drill above on your own data, not the vendor's demo.
Do you make memory layers or context tools for AI agents? Tool makers can ask to be considered for a featured place on this list.
Why teams are looking past Mem0 now
Mem0's pricing page now shows a free plan and a custom one. The free plan covers your model calls for the first 30 days at lower limits, then runs on your own model key with higher monthly limits and usage billing beyond them, up to a cap you set. Higher limits, graph memory or a contract mean talking to them. That's fine for a prototype, and it's one reason people price up the field before they ship.
The rest of the category is drifting too. The memory vendors are sliding towards context: one of the best-known names here now calls itself an enterprise context layer for agents rather than a memory store. If per-user recall is all you need, don't let that pitch talk you into a bigger product.
Two warnings to finish. Don't store everything: saving every message makes recall noisier and the bill bigger, so decide what counts as a fact worth keeping. And don't choose the agent framework last. A memory library tied to one framework is easy if you use it and awkward if you don't, so settle that first with the AI agent frameworks guide.
Want your tool on this list? Featured spots and reviews here are paid partnerships. Here's how to partner with me.
