What is a production memory tool for enterprise agents?

It is a memory layer that stores what agents learn and serves it back on later runs. It comes with the controls an enterprise buyer asks about. Those cover who can read a memory, who decided to store it, where the system runs, what license the code carries and how each plan is billed. For a broader look at nine memory layers sorted by memory type, see our comparison of memory layers for AI agents. The tools below are judged on production and enterprise criteria instead.

The questions this page answers start from mem0, so it is the reference point for every tool here. Its homepage sells it as “Drop-in memory infrastructure for AI agents and apps” mem0.ai, and the library is Apache-2.0 github.com/mem0ai, so it is an easy first layer to try. After the prototype, five questions usually decide the choice. Can several agents share memory with different rights? Can a person approve a memory and trace it to its source? Does the self-hosted edition match the platform? Is there a SOC 2 Type II report? Which features sit on a higher plan?

How do the seven tools compare on enterprise criteria?

Zep and Supermemory state SOC 2 Type II where mem0 states Type 1, Supermemory and Trail document approval steps, and Graphiti, Cognee and Letta can run entirely on your own infrastructure. The hosted services also bill for different things, so the same agent costs a different amount on each.

Seven memory tools on shared memory, governance, self-hosting, license and pricing model (vendor pages, checked 19 October 2026)
ToolShared memoryGovernanceSelf-hostingLicensePricing model by plan
Trail One governed graph that Claude, ChatGPT and your own agents read over MCP, REST or GraphQL; reads are role-scopedEvery rule cites document, page and line; a named approver signs off before any agent can read a rule; SOC 2 Type II on every planSingle-tenant from the Medium plan, in-VPC on LargeWe found no open-source release of the platform; Trail-code, for coding agents, is MITtrailhq.comFree plan; paid plans priced per year, from $20k on Small; no public developer docs yet
mem0 By scope: agents querying the same user_id, app_id or run_id see the same memories; we found no per-agent read policyWe found no approval step or per-memory source citation; a change history per memory exists; homepage states SOC 2 Type 1Apache-2.0 library and Docker server with fewer features; on-prem for the platform listed under EnterpriseApache-2.0 library and server; the README marks advanced features on the self-hosted server as teasersgithub.com/mem0aiCounts add and retrieval requests: free Hobby, Pro at $249 a month, custom Enterprise with SSO and audit logs
Zep Shared Context Graphs for an account, project or domain; ABAC policies per agent keyFacts keep links to their source episodes; memory admission is your application's job; SOC 2 Type II and HIPAA BAA on EnterpriseZep Cloud, Cloud with your own keys, or BYOC in your VPC; Community Edition is deprecatedWe found no open-source license for the service; Graphiti is the open-source corehelp.getzep.comCredits for ingested Episodes, retrieval unmetered; self-serve plans from $125 a month
Supermemory Team seats and per-tag access on Scale; plugins for Claude Code, Cursor and CodexReview queue to approve or decline inferred memories; history endpoint returns source documents; SOC 2 Type IISelf-hosting from Scale at $399 a month; air-gapped on Enterprise; free local binary is single-tenantMIT repository, but the self-hosted server source is not in itsupermemory.aiUnique tokens ingested plus a per-query rate
Graphiti One Context Graph per subject; sharing and access are yours to buildEvery entity and relationship traces to its source episodes; we found no review step; Zep lists governance and compliance as self-managedYou run itApache-2.0github.com/getzepOpen source; Zep is the managed service built on it
Cognee Datasets with permissions, plus tenants and rolesAgents retrieve cited facts; conflict review and feedback, but we found no approval queue before storage; SOC 2 in progressSelf-hosted, Cognee Cloud or BYOCApache-2.0; the production Postgres graph store is licensed separatelygithub.com/topoteretesWe did not record Cognee Cloud plan prices
Letta Memory belongs to each agent, in its own git repositoryThe agent commits its own memory and people review afterwards; we found no provenance links and no SOC 2 or HIPAA statementLocal runtime with no account, or Letta CloudApache-2.0 agent harnessgithub.com/letta-aiWe did not record Letta Cloud plan prices

Facts in this table were checked against the sources listed at the end of this page, between and .

What does each memory tool offer in production?

They fall into three groups: hosted services (mem0, Zep, Supermemory), stacks you run yourself (Graphiti, Cognee, Letta), and a rules layer (Trail) that stores a different kind of memory from the other six.

mem0

mem0 stores extracted memories, not the transcript, and files them under user_id, agent_id, run_id and metadata docs.mem0.ai. Its README sums up the deployment choice: “Just testing? Use the library. Building for a team? Self-hosted. Want zero ops? Cloud.” github.com/mem0ai. For larger buyers the homepage promises “Same API everywhere” across Kubernetes, private cloud and air-gapped installs, with each read and write logged mem0.ai.

Agents share memory by scope. The docs say a filter on one field “matches on user_id alone” and that unmentioned scopes “are not constrained”, so any agent that queries the same user reads the same memories. Each extracted fact is attributed to whoever stated it, “so a record carries user_id or agent_id, not both” docs.mem0.ai, which matters when a planner agent and a critic agent both write about the same user. For team memory, the collaborative task cookbook puts every message in “a shared project space (run_id)” docs.mem0.ai. We found no mention in the docs of a policy that limits which agent may read which memories, so that logic lives in your own code.

We also found no mention on mem0’s pages of a person approving a memory before it is saved, or of a citation from each memory back to the message it came from. Corrections are explicit: “Use explicit update or delete operations when your application needs to correct or remove a memory” docs.mem0.ai.

Self-hosting gives you less than the platform. The open-source retrieval “has no graph memory” docs.mem0.ai, and the README’s comparison table marks advanced features on the self-hosted server as “Teasers” github.com/mem0ai. The homepage states “SOC 2 (Type 1), HIPAA, and GDPR” mem0.ai; a security team that wants a Type II report will have to ask mem0 directly.

On the pricing page, Pro costs $249 a month and is labelled “For production apps with real scale”, while on-prem deployment, audit logs, SSO and custom integrations appear only under the custom-priced Enterprise plan mem0.ai. The Platform docs say “Audit logs and workspace governance ship by default” docs.mem0.ai. The two pages disagree, so get the plan you need confirmed in writing.

mem0 is still a sound pick when the memory is about users and sessions, one team owns the agents, and a wrong fact costs a reply instead of an audit finding. Its README names customer support chatbots and AI assistants as the fit github.com/mem0ai. The docs call the open-source version “the same memory engine as the Platform, running on your own infrastructure” docs.mem0.ai, so you can start in the library and move to the managed service without rewriting calls. The free Hobby plan allows 10,000 adds and 1,000 retrievals a month mem0.ai, which is enough to test retrieval quality on real traffic. If your only gap is a Type II report or on-prem, ask mem0 about its Enterprise plan before planning a move.

Zep

Zep fits several agents that need the same memory with different access rights; if every agent in a scope should see everything in it, mem0’s model is enough. Zep has two kinds of graph. A user graph belongs to one user, and a shared Context Graph holds context that “belongs to a customer account, project, product, organization, or business domain instead of one application user” help.getzep.com. On top sit RBAC for people and ABAC policies for agent keys, plus audit and API logs help.getzep.com. The homepage says “Policies decide what context each agent can retrieve, and every request is logged” getzep.com.

Its policies “do not authorize an action in an external system” help.getzep.com, and the security page leaves “memory admission” to your application help.getzep.com. The pricing page lists SOC 2 Type II, the HIPAA BAA and audit logs against the Enterprise plan only getzep.com. Zep runs as Zep Cloud, Cloud with your own keys, or BYOC in your VPC; the FAQ says the self-hosted Community Edition “is deprecated and no longer supported” help.getzep.com.

Supermemory

Supermemory calls itself “the memory and context layer for AI” and runs memory and document retrieval together by default github.com/supermemoryai. Of the three hosted services, only Supermemory documents review for stored memories: facts the graph inferred stay flagged until someone confirms them, and two endpoints list that queue and record each decision supermemory.ai. We found no review flow for directly stated memories.

“Self-hosted deployments are available on Scale and Enterprise” supermemory.ai, and the free local binary runs as “a single-tenant server with one API key” supermemory.ai. Its security page lists SOC 2 Type II supermemory.ai, as Zep’s does help.getzep.com.

Graphiti

Graphiti is the open-source temporal graph under Zep. The README recommends it to teams comfortable building and operating everything around the core, and it keeps full lineage from each derived fact back to the raw episode github.com/getzep. Zep’s own comparison table puts Graphiti’s governance and compliance down as “Self-managed” help.getzep.com, so access rules and sharing are yours to build.

Cognee

Cognee combines a knowledge graph with vector search and isolates memory per dataset, with tenants and roles on top docs.cognee.ai. Its README links a guide to import memory from Mem0, Letta, Zep or Graphiti in the COGX format github.com/topoteretes, useful if your memory lives in mem0 today. The enterprise page says “SOC 2 is in progress” cognee.ai.

Letta

Letta treats memory as part of the agent. The agent itself chooses where a lesson goes and commits it docs.letta.com to MemFS, a git repository that belongs to that agent docs.letta.com. You get full history and can run it locally with no Letta account docs.letta.com, but because memory is per agent, sharing it across a fleet takes design work.

Trail, for approved company rules

Trail, the memory and context layer for enterprise AI agents, is built for memory where a wrong entry would make an agent break policy, which costs far more than a forgotten preference. Extracted memory suits facts about users. Rules that govern money, compliance or customers need a named approver and a source a reviewer can check.

Its Rule Engine page gives each rule an approval (“A named approver, with a timestamp”), a version history (“Prior versions retained, so past decisions replay”) and access that is “Role-scoped, for people and for agents alike”. Asked whether agents can change rules, the same page answers “No. Agents read approved rules” trailhq.com. Answers from its Context Graph come back with their document, page and line, and when confidence falls under a level your team picks, the agent has to stop and ask trailhq.com.

The homepage says cited rules mean “Claude, ChatGPT, and your own agents all give the same answer”, reached over MCP, LangChain or LlamaIndex retrievers, or REST and GraphQL trailhq.com. Paid plans are priced per year, from $20k on Small; single-tenant starts on Medium and in-VPC on Large trailhq.com.

It is the wrong tool for mem0’s core job. We found no mention on trailhq.com of storing per-user chat memory, and Trail’s blog points teams building their own agents to a memory SDK such as mem0, Zep or Letta trailhq.com. Its docs page still reads “Coming soon” trailhq.com, so developers will need a demo to evaluate the API. One workable setup keeps mem0 for user facts and adds a rules layer beside it. The governance questions behind that split are covered in How should a memory layer for LLM agents be governed?.

How do the hosted pricing models differ?

mem0 meters requests, Zep meters ingestion, and Supermemory meters tokens in plus queries, so one agent can rank cheapest on one service and most expensive on another.

mem0 counts add and retrieval requests per month, with 50,000 retrievals on Pro mem0.ai. Zep charges credits for ingested Episodes by size and says “Memory, retrieval, storage, and users are unmetered” getzep.com. Supermemory bills unique tokens ingested plus a per-query rate supermemory.ai. An agent that reads memory on every turn but writes rarely costs least where retrieval is free; one that ingests long documents costs least where ingestion is cheap.

What should you test before committing to a memory tool?

Test the gap that made you look, on your own data. Test export as carefully as setup, because changing memory tools means moving everything the old one stored.

Before you commit to a memory tool

Checklist
  • Name the gapShared access, approval, citations, self-hosting, compliance or price. A tool that fixes a gap you do not have adds migration cost for nothing.
  • Two agents, one memoryHave a second agent read what the first wrote, then remove its access. If you cannot restrict it without app code, you will be writing the policy layer yourself.
  • Trace one memory to its sourcePick a stored fact and find the message or document line it came from. If you cannot, nobody can audit a wrong answer later.
  • Who decides what gets storedModel, app code, agent or a person. For memories that change what an agent may do, review after the fact can come too late.
  • Self-hosted feature parityRun the edition you would deploy. mem0 gives its self-hosted server only teasers of advanced features, and Supermemory keeps its server source out of the public repository.
  • Compliance scopeAsk whether the SOC 2 report is Type I or Type II and whether it covers the plan and deployment you will buy.
  • Cost at your read and write ratioRequest-based, ingestion-based and token-based billing rank differently depending on how often agents read versus write.
  • Export and importExport a sample from your current store, often mem0, and load it into the candidate. The Cognee README links a COGX import from mem0; for the others, ask the vendor.

If the checklist points to company policy more than user memory, the comparison of context graph tools for AI agents covers the graph side in more depth.

How we chose these seven memory tools

We took mem0 as the reference point because the buyer questions name it, then added six tools that answer the same five questions differently: Zep, Supermemory, Graphiti, Cognee, Letta and Trail. For each we read the homepage, the pricing page where one exists, the documentation, the GitHub README and the license. Facts this page relies on were re-checked on 19 October 2026. The criteria are the table columns: shared memory, governance (citations, approvals, compliance), self-hosting, license and pricing model by plan. Where mem0’s pricing page and docs disagree, we cite both. We did not install, deploy, benchmark or price-test any tool, and we used no vendor benchmark figures. Trail publishes this page and appears in the comparison.

Frequently asked questions

mem0 alternatives for enterprise agent memory?

Zep, Supermemory, Cognee and Trail document access control for enterprise buyers, Graphiti leaves governance to you, and we found no SOC 2 statement on Letta's pages. Zep pairs SOC 2 Type II with ABAC policies and a VPC option; Supermemory states SOC 2 Type II and allows self-hosting from its Scale plan; Cognee says SOC 2 is in progress. On Trail, an agent can read a rule only after a named approver signs it off.

mem0 alternatives for production AI agents?

Pick by the production gap you hit. For SOC 2 Type II plus a deployment inside your own boundary, look at Zep (BYOC) or Supermemory (self-hosted from Scale); for full control of the stack, Graphiti or Cognee; for agents that rewrite their own memory, Letta. Test retrieval on your own data before you move anything.

mem0 vs Zep for shared agent memory?

mem0 shares memory by scope: agents that query the same user_id, app_id or run_id see the same memories. Zep adds shared Context Graphs owned by an account, project or domain, plus ABAC policies that limit what each agent key can retrieve. If several agents need different access to the same memory, Zep has more built in.

Zep vs Supermemory vs mem0 for agent memory?

mem0 is the simplest start for per-user memory and has an Apache-2.0 library. Zep documents the most governance features of the three (ABAC policies, source traceability, audit logs), and its pricing page lists SOC 2 Type II, the HIPAA BAA and audit logs on Enterprise only. Supermemory combines memory with document retrieval and has a review queue for inferred memories.

Is mem0 open source?

The mem0 library and self-hosted server are Apache-2.0. mem0's docs say the open-source retrieval has no graph memory, and its README marks advanced features on the self-hosted server as teasers, with all of them on the managed platform.

Can you keep mem0 and add another memory layer?

Yes, and it is often less work than a migration. Keep mem0 for per-user facts and add a separate layer for what needs shared access, review or citations, such as company policy. Decide which layer answers when the two disagree.

Which of these memory tools work with LangGraph or CrewAI?

mem0's docs list LangGraph and CrewAI integrations for its Platform, and Zep's repository names both among its Python framework integrations. Supermemory's README lists LangGraph and LangChain, and Cognee names LangGraph among its first-party integrations. We found no LangGraph or CrewAI integration on Letta's pages.

Sources checked

Show 44 sources