What agent memory actually is
Every LLM starts each request from zero. It has no idea what your customer said last Tuesday, no memory that they prefer email over phone, no record that they already escalated to a manager. The model is stateless and the prompt is the only place context lives.
Agent memory is the layer that fixes that. Your agent writes things down, then reads them back when it needs them. The important part is that it is not a transcript log. A transcript is a pile of words; memory is a structured set of facts about a user, a project, or a conversation that the agent can query when it needs exactly one of them.
This matters more in 2026 than it did in 2025, because agents now run for minutes instead of seconds and make dozens of tool calls. A support agent that forgets the refund policy mid-conversation is a real cost. A sales agent that re-asks questions the customer answered twenty minutes ago is worse. Memory is what turns a chatbot into something that behaves like it has been here before.
Five tools below are worth shortlisting. I pulled every price from the vendor’s own pricing page, and all of them were checked in the last day or so.
The five tools and what they cost
| Tool | Free tier | Paid entry | What it meters |
|---|---|---|---|
| Mem0 | 10k adds / 1k retrievals a month | Custom quote | Add and retrieval requests |
| Zep | None on self-serve | $125/mo Flex | Credits, 50k included |
| Letta | 3 stateful agents, BYOK | $20/mo Pro | Dollar-denominated credits |
| Cognee | 10M tokens, free workspace | $1 per 1M tokens | Tokens processed |
| Supermemory | $5 of credits a month | $19/mo Pro | Credits at a published rate card |
Mem0: the easiest to start with
Mem0 is where I would point most people first, and the reason is the free tier rather than the architecture.
For the first 30 days you get 10,000 add requests and 1,000 retrievals a month with model calls on Mem0. After that window, bring your own LLM key and the allowance goes to 50,000 adds and 10,000 retrievals. Past your limit, you pay usage-based with a monthly cap you set yourself. There is no self-serve paid tier; the next step is a Custom plan with limits set to your volume, and that is where graph memory, user profiles, Dream consolidation, SSO, audit logs, and on-prem deployment live.
Two features on the Custom tier are worth knowing about before you need them. Graph memory links entities, so if a customer changes the name on their account the memory layer can connect the new fact to the old one instead of leaving a duplicate. Dream is a consolidation job that merges and prunes memories in the background, which is the difference between a memory store that grows forever and one that stays useful.
The catch is that Mem0 moved its paid pricing to custom. There used to be published self-serve plans. Now if you are past the free tier and want more than 50,000 adds, you are talking to sales, which means you cannot price it from a page anymore.
Zep: the deepest memory model, priced in credits
Zep stores memory as a temporal knowledge graph, which means it tracks what is true and when it became true. That matters for any agent where “the customer moved to Berlin in March” needs to supersede “the customer lives in Berlin.”
Self-serve starts at Flex, $125 a month billed monthly, with 50,000 credits included and $25 per 10,000 credits after that. You get 600 requests per minute, 5 projects, 5 Context MCP Server seats, 10 custom entity and edge types, one day of API logs, and unlimited memories, retrieval, and users. Flex Plus is $375 a month with 200,000 credits, 1,000 requests per minute, 10 projects, 15 MCP seats, observations, custom extraction instructions, webhooks, analytics, and 7 days of API logs. Annual billing saves 17 percent.
The thing I like about Zep’s plan design is that memory and retrieval are unlimited on every self-serve tier. You are not charged per fact stored or per query, you are charged for the work the platform does to extract and maintain the graph. For a team that is not sure how much memory it will create, that removes the scariest line item.
Two details that could matter to you. Enterprise plans add SOC 2 Type II, a HIPAA BAA, one-year audit and API log retention, and deployment into your own VPC with your encryption keys. And Zep’s Agent Skills feature is free on every plan until January 4, 2027, after which it presumably becomes a priced feature. If you plan to depend on it, that date is in your calendar.
Letta: memory as part of the agent, not a sidecar
Letta takes a different approach from everyone else here. Where the other tools give you a memory API you call from your agent, Letta builds the memory into the agent runtime itself. The agent has its own state, and you build a persistent agent rather than calling a memory service from a stateless one.
The Free plan gives you up to 3 stateful agents and 5 MiB of storage per memory repository, with no included model usage. Pro is $20 a month and includes $20 a month of credits usable on any model, plus remote sandboxes, up to 20 stateful agents, and 50 MiB per repository. You can add credits whenever you need them.
Letta’s pricing is denominated in dollars rather than abstract units, which makes it the easiest bill to predict and the easiest to underestimate. Letta publishes rough guidance: chat users usually stay within the included $20, limited coding users may fit inside it, casual coding users at a few hours a day typically run around $100 a month or more, and power users running long sessions with many parallel agents often pass $200.
Tool execution has its own line. Server-side tools on the Letta API bill CPU time at $0.00015 per second. Remote MCP tools are billed by the MCP provider, not Letta. Built-in tools are free except web search and fetch. Client-side tools run on your machine and cost you nothing. That last one is a meaningful detail if you plan to do heavy local work through the CLI.
Cognee: priced per token, with no storage charge
Cognee is the odd one out in the cleanest way. It bills $1.00 per 1M tokens processed, and that is the whole pricing model. Your first workspace is free and includes 10M tokens, unlimited users, and unlimited API calls. Each additional workspace is $5 a month.
What I like about this: there is no per-seat charge, no per-document charge, and no per-byte charge for storage. The only recurring charge is the $5 for extra workspaces. You are paying for the processing work, not for the shelf space.
The cap you should know about is storage. Each workspace has a fixed volume cap regardless of whether it is free or paid, so paying buys you tokens, extra workspaces, and support, but not more room. If your corpus grows past the cap, the answer is a new workspace at $5, not a bigger plan. That is a reasonable design for most teams and a strange one if you expected storage to scale with spend.
Supermemory: the most explicit rate card
Supermemory is the one I would point at if you are budgeting, because it publishes a full rate card and shows you what your credits buy in plain numbers.
Every plan comes with a monthly balance of credits at the same rates. Free is $0 with $5 of credits a month, one team seat, and unlimited end users. Pro is $19 a month with $20 of credits, three team seats, and auto top-up with configurable purchase limits. Max is $100 a month with $130 of credits and 6.5 times the credits of Pro, plus a Gmail connector. Scale is $399 a month with $600 of credits, unlimited seats, advanced PDF extraction, S3 and web crawler connectors, SOC 2, a HIPAA BAA, and a self-hosted option. Enterprise is custom.
The rate card: plain-text memory is $0.005 per 1K SM tokens, rich content $0.010. SuperRAG extraction runs $0.001 per 1K tokens for text and $0.002 for rich media including images, PDFs, audio, and video. Semantic search and graph traversal together run $0.005 per 1K queries. Re-ranking, aggregation, and query rewriting cost $0.10 per 1K operations.
Here is how the credits translate. Your $20 Pro credit buys roughly 4M plain-text memory tokens, 20M SuperRAG text tokens, and 4M searches. Scale at $600 of credits buys about 120M, 600M, and 120M respectively. There is one catch worth knowing: if you update a document using the same customId in the same organization, you are billed only the net-new token delta. A full replacement, though, counts as fresh ingestion.
LangMem and the open-source option
LangMem is LangChain’s open-source memory library, and there is no hosted pricing page because there is no hosted product. It is a library you install, backed by whatever store you already run. If you are already on LangChain, it is the path of least resistance, and it gives you control over the storage layer in a way none of the hosted vendors do.
The same goes for the open-source cores of the hosted tools. Mem0 is MIT licensed. Zep and Letta both publish open-source components. If your blocker is that customer memory cannot leave your infrastructure, the honest answer is that you are not locked out, you just have to run the thing yourself.
Which one should you pick
Start with Mem0 if you want a hosted memory API with the most generous free tier and no sales call. Its free allowance of 50,000 adds and 10,000 retrievals with your own key covers a lot of early building, and graph memory is the feature I would want before a production launch.
Choose Zep if time-sensitive facts matter, meaning anything where “when did this change” affects correctness. It is also the pick if you cannot give up unlimited memories and retrieval, and if self-hosting into your own VPC is a hard requirement. $125 a month is not cheap, but it is the most predictable bill in the group because you pay for work done, not for facts kept.
Pick Letta if you want memory to be part of the agent rather than a service you call. It is the most coherent choice for long-running autonomous agents that keep working between conversations, and the $20 Pro entry point is the cheapest real plan here. Budget beyond that if your agents write code.
Choose Cognee if your usage is token-shaped and predictable, if you want storage that does not bill, and if $5 per extra workspace is a small enough constraint. It is the easiest of the five to explain to a finance person.
Use Supermemory when you need to model the bill before you commit. The rate card is published, the credit-to-work mapping is explicit, and there is a self-hosted option on Scale for teams with data residency requirements.
Whatever you pick, run one real conversation through it before you wire it into production. Memory tools have a failure mode that is easy to miss: the agent retrieves a fact that is technically stored but no longer true, and then acts on the stale version confidently. That is worse than an agent with no memory at all, because it looks like the memory is working.
What to actually measure
Two numbers tell you whether your memory layer is pulling its weight. Retrieval hit rate is the share of retrievals that returned something you would have wanted, measured against a set of queries you wrote before you built the thing. Second, cost per successful task, which folds memory cost into the task cost rather than letting it hide in a line item.
Also track one thing most teams skip: how often a stored fact turns out to be wrong. That number tells you whether you need a consistency pass, a consolidation job, or a stricter write policy. Every one of these tools can hold a contradiction. The difference between a good memory layer and a bad one is whether you catch it.
Final word
Agent memory went from an experimental feature to a table stakes item in about eighteen months. The interesting part is not that you can give an agent a memory. It is that you can now write down what the agent remembered and price the storage, the extraction, and the retrieval separately. Pick the tool whose meter matches the shape of your agent, and instrument it from the first week.