Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more

Mem0, Zep, LangChain memory, and Letta solve different memory problems rather than competing as interchangeable APIs. Use Mem0 when an existing agent needs extracted user facts; Zep when facts change and you must answer what was true on a past date; LangChain or LangGraph memory when reliable thread resumption is the immediate need; and Letta when the agent itself should own and edit its memory. Cognee is a fifth option for teams that want a self-hosted, graph-oriented pipeline. There is no evidence-backed universal winner, so choose by memory scope, edit authority, temporal requirements, deployment model, and billing unit.

The products below are listed alphabetically, not ranked. Prices and limits are hosted-plan readings checked in November 2026 and can change; verify the relevant pricing page before committing.

At a glance

Name Best for Key spec Free plan / price Platforms Checked
Cognee Teams wanting a self-hosted graph pipeline Graph-oriented memory assembled from application data Open-source deployment; operating costs are your infrastructure and model calls Self-hosted/local-first November 2026
LangChain memory / LangMem LangGraph thread persistence and optional long-term stores Checkpointer for thread state; LangMem adds episodic, semantic, and procedural patterns No memory-specific hosted price card; pay for database, store, and model calls Self-hosted LangGraph stack November 2026
Letta Stateful agents that manage their own notes Git-backed MemFS plus message history and optional background “dreaming” Free: up to 3 agents with your model key; Pro $20/month Letta Cloud or self-hosted server November 2026
Mem0 Adding extracted user memory to an agent you already run LLM-extracted facts scoped by user, agent, and run; optional graph linking Hosted allowances and plan names changed in late October 2026; see current pricing Managed platform, library, or self-hosted server November 2026
Zep Point-in-time answers and governed context Temporal graph edges with valid and recorded times Free: 10,000 credits/month; Flex $125/month for 50,000 credits Zep Cloud; Graphiti for self-hosting November 2026

Prices checked November 2026.

“LangChain memory” is a framework design, not a fifth hosted memory service. The table includes Cognee because it is a practical graph-oriented alternative when the four named architectures do not fit.

What’s actually slowing this PC down?

Pick the symptom - the matching free tool is one click away.

Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

What does “memory” mean for an AI agent?

Start by naming the job. Memory can mean continuing an active thread, carrying user facts into a later session, preserving which fact was valid on a particular date, or letting an agent maintain editable notes. A system optimized for one job is not automatically suitable for the others.

  • Thread continuity: save conversation state, summaries, and recent turns so a run can resume.
  • Cross-session facts: retain preferences, decisions, and profile details for a user or application.
  • Temporal truth: keep superseded values and their validity intervals so a question such as “What plan did the customer have in March?” has an auditable answer.
  • Agent-owned notes: give the agent a workspace it can inspect and rewrite as it learns.

These distinctions explain the architecture split summarized by RottenWiFi’s four-way comparison and the definitions collected by the past.dev team.

How do the four main architectures differ?

Architecture Memory unit Who edits it? Temporal behavior Integration shape
Mem0 Extracted facts and optional entity links Extraction and consolidation pipeline Timestamps, expiry, and consolidation; not a full validity-history system in the open-source descriptions Add a library or service to an existing agent
Zep / Graphiti Entities and fact edges Graph-construction pipeline Bi-temporal valid and recorded times; superseded facts remain queryable Hosted context graph or self-hosted Graphiti
LangGraph / LangMem Thread checkpoints plus application-defined long-term records Developer-controlled persistence logic Checkpoint history; no native fact-validity graph Stay inside a LangGraph application
Letta Agent-owned files in MemFS plus message history The agent through file or memory tools Git history records file changes; the agent decides what to rewrite Adopt the Letta agent runtime

That integration choice is the largest practical trade-off. Mem0 is a layer you call. Zep adds a context graph. LangChain gives you persistence primitives and leaves policy to your code. Letta changes the software unit from “your agent plus memory” to “a stateful agent whose memory is part of its runtime.”

Which agent memory should I use?

  1. Name the required memory job. Write down whether you need thread resumption, cross-session facts, point-in-time truth, or agent-owned notes.
  2. Choose the least invasive architecture. For a LangGraph thread, begin with a production checkpointer. Add a long-term store only when a fact must survive a new thread.
  3. Choose by change history. If a changed preference must retain its old value and date, shortlist Zep or self-hosted Graphiti. If you only need a current preference on an existing agent, Mem0 is a closer fit.
  4. Choose by agent ownership. If the agent should decide what to keep, open, and rewrite, consider Letta and accept the runtime commitment.
  5. Price the actual meter. Mem0 counts add and retrieval requests, Zep counts ingested bytes as credits, Letta counts agents and tool-execution seconds, and LangChain counts your database, store, and model calls. As Aditya Sharma puts it, “These three bills are not comparable line by line. Mem0 meters requests, Zep meters credits, Letta meters agents and tool seconds.”
  6. Run change-of-fact checks before adoption. Change one user attribute, ask for both old and new values with dates, merge three identifiers for one person, and ask an unanswerable question to see whether the system admits uncertainty.

1. Cognee: who it is for

Cognee suits teams that want a graph-oriented memory pipeline they can run themselves rather than adopting a hosted extraction API or a complete agent runtime. It is a neighboring option in this comparison, not one of the four architectures named in the title.

Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

Its practical appeal is control over the ingestion and graph layers. A self-hosted deployment means selecting and operating the graph or vector database, model providers, backups, access controls, and deletion workflows. Software licensing can be zero, but database capacity and extraction-model calls are not.

Free and paid use: Cognee is commonly positioned as an open-source, self-hosted project. A hosted tier and price are not included here, so treat infrastructure and model usage as the budget rather than assuming a managed free allowance.

Upgrade or choose it when: your team needs to own the data path, customize graph construction, or avoid a hosted context service. It is less suitable when the requirement is a turnkey, per-user memory API or a stateful agent with built-in operational tooling.

2. LangChain memory / LangMem: who it is for

Choose LangChain memory when the immediate requirement is reliable state for an application already built on LangChain or LangGraph. A checkpointer persists thread state—conversation history, intermediate state, and summaries—so a run can resume. For production, the current documentation recommends a database-backed checkpointer rather than process-local state.

Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

Long-term memory across threads is a separate design. LangMem supplies tools and a background memory manager that persist through LangGraph’s store; the application still decides namespaces, write rules, retrieval prompts, and deletion behavior. Descriptions of LangMem include episodic, semantic, and procedural memory patterns, commonly implemented with key-value records and vector similarity rather than a temporal knowledge graph.

Free and paid use: there is no memory-specific hosted price card in the cited material. Budget the checkpointer database, any LangGraph store, embedding and language-model calls, backups, and operational support. LangMem is described as MIT-licensed and self-hostable, but it requires the surrounding LangGraph infrastructure.

Upgrade or choose it when: your team already owns a LangGraph application, wants policy in application code, or needs to avoid adding a separate memory vendor. Add a dedicated memory service only when your requirements exceed checkpoint and store primitives—especially point-in-time fact queries or agent-managed notes.

3. Letta: who it is for

Letta is for teams that want the agent itself to be persistent. The documented late-2026 model uses MemFS, a git-backed filesystem that the agent reads and edits with ordinary file tools, alongside message history. Optional background “dreaming” lets subagents review conversations, consolidate lessons, and update memory between sessions.

Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

This design can make memory behavior inspectable as files and commits, but it creates more runtime coupling than a drop-in API. You adopt Letta’s agent harness, model configuration, tools, and server rather than retaining complete control of an existing agent loop. Letta’s README describes the project as formerly MemGPT; newer documentation emphasizes the MemFS-based model.

Plans and usage: the pricing reading checked in October and November 2026 lists a free tier for up to three stateful agents with your own model key; Pro at $20 per month; and Teams Pro at $20 per seat per month. The API plan is described as $20 per month plus $0.10 per active agent per month and $0.00015 per second of tool execution, with model tokens passed through at provider rates. Some Letta surfaces may present different production or sales-assisted terms, so check which product—Cloud, API, Teams, or Code—you are buying.

Upgrade or choose it when: long-running agents must maintain and revise their own notes, and the team accepts operating a stateful runtime. A conventional agent plus Mem0 or LangGraph is a better fit when you need a memory layer without replacing the agent loop.

4. Mem0: who it is for

Mem0 is a memory layer for an agent you already have. An add call sends messages through an extraction pipeline that identifies facts, decisions, and preferences; those memories can be scoped with user_id, agent_id, and run_id. Optional graph memory links co-occurring entities and combines that signal with relevance ranking. Deployment options include a managed platform, a library, and a self-hosted server; the open-source repository is Apache-2.0.

Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

Mem0’s design center is salient conversational memory, not a bi-temporal system of record. Sources disagree on how open-source and managed versions handle corrections: descriptions range from add/update/delete decisions to add-only writes with timestamps and expiry, while the platform is described as offering date-aware ranking and change history. Test real corrections instead of assuming that a new preference automatically overwrites the old one.

Hosted plans and the late-2026 transition: an October 11, 2026 pricing-page reading listed Hobby at no cost with 10,000 add requests and 1,000 retrievals per month; Starter at $19 per month with 50,000 adds and 5,000 retrievals; Pro at $249 per month with 500,000 adds and 50,000 retrievals, including graph memory; and Enterprise as custom. Later readings dated October 27 through November 10 describe a transition in which new accounts receive a 30-day Mem0-paid allowance of 10,000 adds and 1,000 retrievals, then a bring-your-own-key allowance of 50,000 adds and 10,000 retrievals, with model usage above that billed separately. One November reading says older paid plans were closed to new accounts and that existing customers had until November 25, 2026, to connect a key. Because these reports describe changing plan regimes, open the dated pricing comparison and Mem0’s current pricing page on the day you sign up.

Under the bring-your-own-key description, recommended model usage is reported at roughly $3.55 to $5.34 per 1,000 adds. The operational trap is retrieval volume: a chat product can exhaust a 1,000-retrieval allowance before it reaches its add cap.

Upgrade or choose it when: you need a small integration surface, per-user personalization, and extracted facts behind an existing agent. Pay for a higher tier or your own model key when request volume, graph relationships, or model-cost control justifies it; do not buy it solely because a benchmark number appears higher than another product’s number.

Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

5. Zep: who it is for

Zep fits applications that must answer not only “what is true now?” but also “what was true then?” Its Context Graph models entities, relationships, and facts as temporal edges with created, valid, invalid, and expired times. New information invalidates a superseded fact rather than deleting it, enabling point-in-time retrieval and an assembled context block for the agent.

Zep Cloud is the hosted product. Graphiti is the maintained open-source temporal-graph engine associated with Zep; the older Community Edition server is no longer maintained. Self-hosting Graphiti requires your own graph database and operations. Do not treat cloning the old getzep/zep repository as equivalent to running the current hosted service.

Plans and billing: the free tier is reported at 10,000 credits per month. Flex is $125 per month for 50,000 credits; Flex Plus is $375 per month for 200,000 credits. Flex overage is reported at $25 per additional 10,000 credits. One credit covers an ingested episode up to 350 bytes, with one additional credit for each further 350-byte unit or part. Retrieval, storage, threads, users, and graph storage are described as not consuming credits; enterprise is the tier associated with bringing your own model keys in the cited pricing readings.

Upgrade or choose it when: changed facts, auditability, and date-aware answers matter more than the smallest integration. Use Graphiti when the team can operate a graph database and wants the open-source engine; use Zep Cloud when managed ingestion, retrieval, and governance are worth the hosted bill.

Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Support on Ko-Fi

How should I evaluate memory behavior before signing a contract?

Run a small, repeatable acceptance suite against the exact model, version, and deployment you will buy. Architecture diagrams cannot prove that a correction, deletion request, or identity merge behaves correctly in your workload.

  1. Correction test: write “the user lives in Austin,” change it to “the user lives in Denver,” then ask for both values with dates.
  2. Identity test: provide an email address, chat handle, and ticket identifier for one person and verify whether the system resolves them to one entity.
  3. Scope test: confirm that a fact intended for one user, agent, or run does not leak into another scope.
  4. Deletion test: remove a memory and inspect indexes, graph edges, backups, and exported context for remnants.
  5. Unknown-answer test: ask for a fact never stored and require an explicit “unknown” rather than a plausible completion.
  6. Load test: measure model calls, write latency, retrieval latency, and database growth at expected concurrency. Published figures are not interchangeable: Spheron’s secondary retelling reports roughly 500 milliseconds for a Mem0 single-pass write and about three seconds for a Zep graph write, while its search table lists sub-second p50 and p95 values for both. Those numbers are workload-specific, not a four-way benchmark.

What do the published benchmarks actually prove?

They do not establish a neutral winner. The cited papers use different tasks, models, baselines, and implementations, as RottenWiFi notes.

For example, the Mem0 paper reports a 26% relative improvement in its LLM-as-a-Judge metric over an OpenAI baseline on its LOCOMO setup, about a 2% improvement for its graph variant over base Mem0, 91% lower p95 latency, and more than 90% token-cost savings versus its full-context method. The Zep paper reports 94.8% accuracy on its DMR setup with GPT-4 Turbo, compared with 93.4% for the cited MemGPT result and 94.4% for a full-conversation baseline; with GPT-4o-mini it reports 98.2% versus 98.0% for full conversation. These are study results, not a shared product leaderboard.

Even LongMemEval figures conflict across sources: a managed Mem0 README reading reports 94.4, while another secondary report cites 49.0 for a different setup and 95.4 for LangMem. Hosted versus open-source builds, prompts, models, retrieval budgets, and harnesses can move scores by tens of points. Use benchmarks to understand a method, then validate your own workload.

Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

What costs are easy to miss?

  • Meter mismatch: Mem0 counts adds and retrievals; Zep counts ingested bytes; Letta counts agents and tool seconds; LangChain shifts cost into your database, store, and model provider.
  • Model ownership: bring-your-own-key changes who receives model traffic and who pays for extraction or summarization.
  • Write amplification: graph extraction may require more model calls and storage than flat fact extraction.
  • Self-hosting: open-source licenses do not remove database, backups, observability, patching, or on-call costs.
  • Plan transitions: Mem0’s late-October 2026 pricing changes make account age and signup date material; record the plan and limits shown at purchase.
  • Retention and compliance: define export, deletion, tenant isolation, and recovery procedures before placing private conversations into a hosted memory service.

Decision checklist

Choose Mem0 for a bolt-on fact layer on an existing agent. Choose Zep or self-hosted Graphiti when validity intervals and historical truth are requirements. Choose LangGraph checkpointers for dependable thread continuity, adding LangMem only for cross-thread records. Choose Letta when the agent should own an editable workspace. Choose Cognee when local-first graph construction and infrastructure control outweigh a turnkey hosted API.

The final decision should document memory scope, correction semantics, inspection and deletion controls, data ownership, recovery, expected model calls, and the vendor’s billing unit. Those criteria matter more than star counts or an isolated benchmark percentage.

Frequently Asked Questions

Is Zep open source?

The maintained open-source component is Graphiti, a temporal knowledge-graph engine. Zep Cloud is the hosted product, while the older Community Edition server is described as discontinued and unsupported; self-hosting therefore means operating Graphiti and its graph database.

Is Letta the same project as MemGPT?

Letta’s README describes it as formerly MemGPT. The late-2026 documentation emphasizes stateful agents with MemFS, while older explanations use the Core, Recall, and Archival terminology from the MemGPT lineage.

Free tools Windows power users keep installed

One-click scans. No signup required.

Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

Can Mem0 answer what a user believed three months ago?

Mem0 can accept a backdated timestamp and retain multiple memories, but its open-source and managed correction behavior is described differently across versions. If historical truth is a requirement, test dated retrieval directly or use a system with explicit validity intervals.

How do I budget LangChain memory?

Estimate the database or hosted store for checkpoints, embedding and language-model calls, retention, backups, and observability. There is no single memory-credit meter, so cost follows the infrastructure and persistence policy your application chooses.

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply. Prices as of November 21, 2026 3:03 am GMT.