Mem0 vs Zep vs Letta: memory for customer-facing AI agents

To give an agent long-term memory, open source or fully managed, Mem0 does it with two calls: add() and search(). For memory built on a temporal knowledge graph, with per-agent access policies, choose Zep; Graphiti, its open-source engine, suits teams that want to run the graph themselves. To build an agent that edits its own memory and learns with use, go with Letta. When agents from different vendors serve the same customer on WhatsApp, voice and the app, with no shared user ID, Niadra covers what the other three do not document: recognizing the customer across channels.

The facts about Mem0, Zep and Letta come from their official documentation and websites, checked in September 2026, with a link next to each one. Where the information does not appear, the table says "not documented". Niadra wrote this post.

Mem0, Zep, Letta and Niadra side by side

Mem0: memory for the agents your team builds

Mem0 is a memory layer for AI agents and apps. Your application sends each exchange to add(), and Mem0 extracts the facts worth keeping. Before the next model call, the application runs search() and decides what goes into the prompt (how it works). Each memory is tied to IDs your app supplies, such as user_id and agent_id (entity scoping).

The code is open source under Apache 2.0, and the same API runs on the managed platform (Platform vs open source). The docs cover integrations with LangChain, CrewAI, LlamaIndex, LiveKit and dozens more (integrations).

Mem0's customer support page promises memory across chat, email and voice. The documentation, however, does not describe identity resolution across channels: memory follows whatever user_id your app sends. According to its website, as of September 2026, Mem0 is SOC 2 Type I, HIPAA and GDPR compliant.

When to choose Mem0

• You have one agent, or a few, built by your team, and a stable user ID on every channel.
• You want open source and self-hosting, with the vector database and LLM of your choice.
• You want a ready-made integration with the framework you already use.

Zep: a temporal knowledge graph with governance

Zep delivers agent memory on top of a temporal knowledge graph, built from chat, business data, documents and JSON. Every fact records when it became true and when it stopped being true (facts). The engine behind the graph is Graphiti, which is open source.

Zep assembles the agent's context block using the four most recent messages in the conversation as the query, in under 200 ms for 95% of calls (retrieving context).

Governance is a real strength. According to the documentation, as of September 2026, the Enterprise plan attaches policies to each API key that limit which actions an agent can take and which classes of data it can read (agent access). The API log records every call along with the policy decision (API logging). Zep holds SOC 2 Type II and signs HIPAA BAAs with Enterprise customers (security). Zep Community Edition, the self-hosted version, is deprecated, and teams that want to run everything themselves use Graphiti (FAQ).

When to choose Zep

• You need to know when each fact became true and when it stopped, such as a plan change.
• You want conversations and business data in the same user graph.
• You need per-agent policies, SOC 2 Type II, or the service deployed in your company's own cloud (security).
• You want your team to operate the graph as open source: in that case, Graphiti.

Letta: agents that manage their own memory

Letta, formerly MemGPT (GitHub), is a platform for building stateful agents that learn from experience. According to the documentation, as of September 2026, memory belongs to the agent and lives in a git repository. Files in the system/ folder go into the prompt on every turn, and the agent reads the rest when it needs to (memory). The agent edits that memory itself, and background subagents reorganize what it has learned (MemFS).

The code is open source under Apache 2.0. Letta runs locally or on your own server, and Letta Cloud is the hosted option (self-hosting). The docs list coding agents, personal assistants, AI coworkers and agents embedded in applications as its uses (documentation). Recognizing the same customer across channels is not covered.

When to choose Letta

• You are building your own agent and want memory inside the framework.
• You want an agent that edits its own memory, with version history in git.
• You need to run everything locally, including the model.

Niadra: shared memory for omnichannel customer service

Niadra is the shared memory for a company's AI agents, built for omnichannel customer service: WhatsApp, voice, the app and human agents, with AI agents from different vendors. It does not build agents: it connects the agents you already have to the same memory.

Niadra recognizes the customer without relying on a ready-made ID: phone, email, tax ID and login become one customer, with a confidence level (how it works). Each agent reads only what its purpose allows. Every read goes into a record chained by SHA-256, and the company can cut a vendor's access on the spot. Niadra acts as a processor under GDPR and LGPD, with a DPA and erasure with a receipt.

When Niadra is not the right fit

• One agent, one channel and a reliable user ID. Mem0 or Zep handles that case directly.
• Your own infrastructure, or an open-source memory engine. Niadra is fully managed and has no self-hosted version. Mem0, Graphiti and Letta do.
• A framework to build the agent. Niadra is not an agent framework. Letta is.
• A proven track record. Niadra is new: it has no GitHub stars, no integrations listed in frameworks and no published benchmark. The other three have communities, published papers and documented integrations.

How to choose between Mem0, Zep, Letta and Niadra?

1. How many vendors serve the same customer? If your team builds the agents, Mem0, Zep and Letta fit well. If competing vendors handle different channels, the memory needs a credential and permissions per vendor. Zep offers that on its Enterprise plan, and Niadra was designed for this case.
2. Is there one user ID shared by every channel? If there is, Mem0 and Zep work with it directly. If the customer arrives by phone on one channel and by login on another, something has to connect the two: in Niadra, that is part of the product; with the other three, it falls to your application.
3. Where does the memory need to live? On your own infrastructure, as open source: Mem0, Graphiti or Letta. As a managed service: Mem0, Zep, Letta Cloud or Niadra. In your company's own cloud or data center, under contract: Zep and Mem0.

Before you commit, test each option with real conversations that switched channels.

How Niadra handles it

The SDK, in Python and TypeScript, has three calls:

# before replying: the full customer context
ctx = niadra.context(phone=caller_id, channel="voice")

# during the conversation: the agent searches the history
results = niadra.search(ctx.customer, "credit for missed technician visit")

# after replying: the conversation goes into the memory
niadra.track(conversation=call_id, channel="voice", turns=[question, reply])

context() needs no query and returns the full context in under 100 ms, with the channel and time of every fact. History search also works through the HTTP API and MCP. Pricing is per conversation: US$ 5 to 15 per thousand conversations, with the Regulated plan priced under contract. See Products, Security and Pricing.

Frequently asked questions

What are the Mem0 alternatives for production agents?

Three alternatives cover different cases: Zep, for a temporal knowledge graph and per-agent policies; Graphiti, for running that graph as open source; and Letta, for memory inside the agent's own framework. For omnichannel customer service across vendors, Niadra recognizes the customer on every channel.

Zep vs Mem0 vs Letta: which one fits customer-facing agents?

With one agent and a stable user ID, Mem0 and Zep fit well, and Zep adds time-bounded facts and per-agent policies. To build the agent itself, Letta is the framework for it. With different vendors across several channels, Niadra handles identity and governance between them.

Does Niadra have a self-hosted or open-source version?

Not the platform. Niadra is fully managed: it runs all the infrastructure, and the customer connects the SDK, which is open source so the security team can audit everything that leaves the network. On the Regulated plan, the company gets a dedicated environment, run by Niadra. To run the memory engine on your own infrastructure, Mem0, Graphiti and Letta are mature options.