What are the best agent memory options for multi-user chatbots with scalable history?

As of October 2026: Mem0 is the best default, scoping every memory by user_id, agent_id, app_id and run_id with unlimited end users on every plan (Free, $19, $249 a month). Zep is best when facts change over time and you need a temporal knowledge graph, with credit plans from $125 a month and SOC 2 Type II. LangGraph's checkpointers plus a store in your own Postgres are best if you want no vendor and full control. Letta is best when each user should get a long-lived stateful agent rather than a memory layer.

How do I keep one user's memories from leaking to another user?

Tag every write and every read with the user's ID and enforce the filter on the server, never in the prompt. Mem0's Platform API scopes memories by user_id, agent_id, app_id and run_id; LangGraph stores use namespaces such as (user_id, 'memories'). Add a test that queries as user A and asserts nothing from user B comes back, and run it in CI.

Do I need a memory layer or just chat history?

Chat history (the raw transcript per conversation thread) is enough if users only continue the same conversation. You need a memory layer when the bot must remember facts across conversations, such as preferences, account details or past decisions, without replaying whole transcripts. Most production bots use both: thread history in a checkpointer or database and extracted long-term facts in a memory service.

Quick Answer

Best Agent Memory for Multi-User Chatbots (2026 Guide)

Published: October 7, 2026

The short answer

Mem0 is the default memory layer for a multi-user chatbot in 2026: per-user scoping is built in, every plan allows unlimited end users, and it starts free. Pick Zep when facts change over time, LangGraph stores on your own Postgres when you want no vendor, and Letta when each user should own a persistent agent. Prices are list USD as of October 7, 2026.

Two problems, not one

A multi-user chatbot has to solve two things:

Scalable history — the transcript of each conversation thread, loaded fast when a user returns. This is a database problem (Postgres, Redis, a checkpointer).
Long-term memory — facts extracted across threads (“prefers metric units”, “on the Pro plan”) and retrieved by relevance. This is what memory products sell.

Do not push full transcripts into a memory service, and do not search raw transcripts when you need facts.

The comparison

Option	Per-user isolation	History vs memory	Pricing (Oct 2026)	Scale notes	Best for
Mem0 Platform	`user_id`, `agent_id`, `app_id`, `run_id` on every write and read	Memory layer; history stays in your DB	Free: 10K adds, 1K retrievals/mo · Starter $19: 50K / 5K · Pro $249: 500K / 50K + graph memory · Enterprise custom	Unlimited end users on all plans; open-source version self-hosts	Default choice
Zep	Per-user graphs; unlimited users	Temporal knowledge graph from messages (“episodes”)	Free 10K credits · Flex $125/mo (50K credits) · Flex Plus $375/mo (200K credits)	1 credit per episode up to 350 bytes; 600–1,000 req/min on Flex; SOC 2 Type II	Facts that change over time
LangGraph checkpointer + store	Thread IDs + store namespaces you define	Both: checkpointer = thread history, store = cross-thread memory	Open source; your Postgres	Scales with your database	Full control, no vendor
Letta	One stateful agent per user	Agent owns its memory blocks and history	Developer plans usage-based; tool execution $0.00015/sec	Unlimited agents on developer plans	Long-lived personal agents

Notes per option

Mem0. The Platform API separates memories by user, agent, app and run, so a support bot can keep per-customer facts (user_id), per-ticket context (run_id) and per-agent context for a planner and a critic (agent_id). Watch the retrieval quota — retrievals, not users, are what you run out of: Starter allows 5,000 a month, so a bot that searches memory on every message needs Pro or usage-based pricing quickly.

Zep. Ingests each message as an “episode” and builds a temporal graph, so “moved from Berlin to Tallinn in May” replaces the old fact instead of contradicting it. Billing is by ingestion volume (a 1,200-byte episode costs 4 credits), not by storage or retrieval. HIPAA BAAs require the Enterprise plan.

LangGraph. Its persistence layer has two parts: checkpointers keep a thread’s state (short-term memory, resumption, human-in-the-loop) and stores keep application data across threads (long-term memory). With a Postgres checkpointer and store you get scalable history and per-user memory in infrastructure you already run, but extraction and relevance ranking are your code.

Letta. Gives each user an agent that edits its own memory. Powerful for companions and assistants that evolve; more than you need for a support bot that only has to remember a few facts.

How to choose

Situation	Pick
SaaS support or sales bot, thousands of users	Mem0 (Pro once retrievals pass 5K/month)
Health, finance or CRM bot where facts change	Zep
Data must stay in your Postgres, team knows LangGraph	LangGraph checkpointer + store
Each user gets a persistent personal agent	Letta
Under 1,000 users, simple facts	Postgres table of facts + embeddings

Whatever you pick, enforce the user filter server-side, set a retention period, and give users a way to see and delete what the bot remembers.

The full ranking of memory systems is in best AI agent memory systems; the concepts are in agent memory vs chat memory vs RAG.

Last verified: October 7, 2026. Prices are list USD from vendor pricing pages.

The short answer

Two problems, not one

The comparison

Notes per option

How to choose

Related

Sources