Best Persistent Memory Systems for AI Agents 2026

Mem0 is the best default persistent memory system for an AI agent you are building, while Perplexity Brain is the best no-build choice. The fresh business signal is Perplexity's vendor-reported result: 25% higher correctness, 16% higher recall, and 13% lower cost on Computer tasks that needed historical context.

The Short Answer: Which Persistent Memory System Should You Pick?

Choose Mem0 when you need a memory API inside your own product and want a sensible path from a free prototype to a managed production service. Choose Perplexity Brain when the agent already lives in Perplexity Computer and the goal is to remove recap work without building memory infrastructure. Choose Hindsight when the agent must reason across changing facts and long histories, or Zep when a governed temporal knowledge graph is the center of the design.

The rest of the ranking is more specialized. Supermemory is strongest when conversations, documents, and connectors need one multimodal context layer. Cognee fits teams that want a graph-vector-relational engine they can run locally or deploy into their own cloud. Claude Managed Agents memory stores are the cleanest audit-first option inside Anthropic's managed agent runtime. Letta is the portability pick for coding agents whose identity should survive model changes. LangMem is the library-first choice when you already build in LangGraph and want to own the storage and policy.

Prices below were verified on August 28, 2026. "Free" may mean a hosted free tier, a self-hosted open-source path, or a free application with separate model and infrastructure charges. Those are not economically identical, so each section names the real bill.

The ranking is deliberately not a benchmark leaderboard. A memory system can retrieve brilliantly and still be the wrong purchase because it cannot satisfy your deletion policy, tenant boundary, latency target, or operating model. The best system is the one whose persistence boundary matches the thing you are trying to remember.

If that sentence sounds abstract, use this decision rule: buy a managed product when its monthly premium is lower than the engineering time you would spend operating extraction, consolidation, retrieval, correction, and deletion yourself. Own the stack when the data boundary or memory behavior is the non-negotiable. That rule flips more choices than a small benchmark lead.

What You Are Actually Buying

Persistent memory is not a larger prompt. A context window is what the model can see during one inference. A checkpoint lets a workflow resume from a saved state. Durable memory decides what survives, how it changes, and what small slice should return to a future session. A governed knowledge layer adds ownership, provenance, retention, and deletion around that memory.

Those layers solve different failures. If an agent needs to resume the exact step after a crash, use a checkpoint. If it needs to remember that a customer changed billing contacts last month, use durable memory with temporal validity. If it must prove why that contact appeared in an answer, add source links or immutable versions. If one customer's facts must never leak into another's run, tenancy is part of memory, not an afterthought.

The budget consequence is the context reload bill: model input spent re-sending old material, human time spent recapping it, and failed work caused by stale or contradictory context. Perplexity puts a current number on one version of that problem. Its Brain launch report says Computer tasks that required historical context cost 13% less with Brain in its early measurement, alongside 25% higher correctness and 16% higher recall. Those are vendor-reported results on Perplexity's own product, not a general benchmark, but they show the right economic target: fewer calls and less repeated context while answer quality rises.

The strongest systems attack that bill in different ways:

• Selective retrieval brings back a small relevant subset instead of replaying the full history.
• Consolidation merges duplicates and promotes repeated patterns into a shorter working model.
• Temporal reasoning distinguishes what was true from what is true now.
• Correction lets a user or host application repair bad memory before it compounds.
• Provenance makes a remembered claim inspectable rather than merely plausible.
• Tenant controls keep memory scoped to a user, project, agent, or organization.

That is why a vector database alone is not the whole answer. It can store embeddings and return similar passages. It does not automatically decide whether a fact has been superseded, whether a correction should rewrite an observation, whether an old source must be deleted, or whether a preference belongs to the user, agent, run, or company. Systems such as Hindsight, Zep, Mem0, Supermemory, and Cognee add policy and structure around retrieval. File-native systems such as Claude memory stores and Letta's context repositories make the state inspectable in a different way.

The boundary matters more than the interface. Perplexity Brain remembers work performed inside Computer; it is not a neutral API for your SaaS. Claude memory stores persist small documents inside Managed Agents; they are not an automatic knowledge graph. Mem0 and Supermemory are application services; they still require you to decide when your agent writes, searches, and forgets. Cognee and Graphiti give you more ownership, then hand you more infrastructure responsibility.

This is also where memory and agent skills separate. A skill is usually a durable instruction for how to do work; memory is learned state about what happened, what changed, and what matters now. The distinction is useful when choosing between persistent agent skills and learned context. Stable policy belongs in a skill or system configuration. A customer's newest constraint belongs in memory. Mixing them makes both harder to audit.

The Cost Math Before the Rankings

Memory prices look comparable until you inspect the billing unit. One vendor bills input tokens retained, another bills unique tokens embedded, another bills tokens processed, and another bills small Episodes. A dollar-per-million comparison without those nouns is false precision.

Consider a 10-million-token ingestion job:

• Hindsight charges $100 to Retain 10 million input tokens at $10 per million. If all 10 million remain beyond the 30-day grace period, storage adds $2.50 per month. Recalling 10 million output tokens would cost $7.50, although a well-designed application should retrieve far less than it stores.
• Supermemory charges $50 for 10 million plain unique SM tokens in its memory graph at $0.005 per 1,000. Rich content would be $100. The important modifier is unique: repeats and unchanged content are not billed again.
• Cognee Standard charges $25 to process 10 million tokens at $2.50 per million. Three additional workspaces add $15, producing a modeled $40 month for that volume and workspace count.

Those numbers do not prove Cognee is four times cheaper than Hindsight. Hindsight's Retain operation performs a particular extraction and memory process; Supermemory bills its own deduplicated token definition; Cognee measures tokens its engine processes. They are three meters attached to three different workloads.

Zep makes the tier boundary unusually clear. Flex costs $125 and includes 50,000 credits, then adds 10,000 credits for $25. Ten top-ups bring the bill to $375 and total capacity to 150,000 credits. Flex Plus already costs $375 and includes 200,000. Above a 150,000-credit monthly forecast, Flex Plus becomes the cheaper tier before its higher limits and longer rollover have any value. At 160,000 credits, Flex would cost $400 while Flex Plus remains $375.

Perplexity's arithmetic is seat-led rather than API-led. Consumer Max is $200 monthly or $2,000 annually. Ten seats cost $24,000 if paid monthly for a year versus $20,000 annually, a $4,000 yearly difference. Enterprise Max is $325 per seat monthly or $3,250 annually, so ten seats save $6,500 per year on annual billing. Annual commitment only makes sense after the workflow proves that Brain removes enough recap and rework to earn the lock-in.

Claude exposes another cost lever. Sonnet 5 is $2 per million input tokens and $10 per million output tokens. A run mix with 10 million input tokens and 1 million output tokens costs $30 before any other runtime charges. Re-sending a 100,000-token brief across 100 sessions creates 10 million input tokens, or $20 at the published input rate before cache effects. A memory store does not make reads free, but it gives the agent a chance to retrieve the relevant file instead of stuffing the entire brief into every opening prompt.

The Monday budget question is therefore not "Which vendor has the lowest starting price?" It is "What does one remembered unit mean here, how often will it be written and read, and who pays when it is wrong?" Price the write path, retrieval path, retained storage, model inference, and correction labor separately. Then add the managed premium or the engineer-hours required to operate the open stack.

How These Systems Were Picked

Nine systems made the list because each offers a real persistence mechanism and a distinct buying reason. The field was narrowed with six criteria:

1. Persistence boundary: Does state survive a process restart, a new session, a model change, or an application redeploy? Who owns that state?
2. Retrieval quality: Can the system combine semantic, lexical, graph, and temporal signals, or is it only nearest-neighbor search?
3. Correction and provenance: Can you inspect why a memory exists, update it safely, track versions, and delete it?
4. Tenancy and control: Can you isolate users, projects, agents, and organizations? Can you self-host, use BYOC, or enforce read-only access?
5. Operating work: What must your team still build around extraction, consolidation, evaluation, monitoring, retention, and security?
6. Bill shape: Does the vendor charge by seat, request, token, Episode, storage age, operation, or infrastructure?

Every price, tier, limit, and named capability here was checked against a first-party pricing page, documentation page, repository, or product announcement during this run on August 28, 2026. The products were not personally exercised for this article, so the title does not claim "Tested." Vendor benchmarks are labeled as vendor-published rather than presented as independent findings.

The cuts matter too. Plain vector databases were excluded as complete memory systems because storage and similarity search do not supply a full memory lifecycle. General agent frameworks without a durable memory layer were excluded. Consumer chat memory that cannot be inspected, scoped, or integrated was excluded unless it formed a substantive agent workflow, which is why Perplexity Brain qualifies and generic personalization toggles do not.

The ranking favors decision usefulness over category purity. Perplexity Brain and Letta are not interchangeable with Mem0's API, but both answer the same budget question for a buyer: build a memory layer, adopt one inside a managed workspace, or choose an agent runtime that owns it. Keeping those options together makes the build-versus-buy decision visible.

1. Mem0: Best Default Memory API for Product Teams

Mem0 is the best default when a product team needs cross-session memory without committing first to a temporal graph, file-native runtime, or one vendor's agent workspace. A support agent can scope memory by customer and run, retrieve the few relevant preferences before answering, and correct or expire them later. The managed platform adds consolidation and temporal ranking that the open-source edition does not have. The real wall is the plan jump: the $19 Starter tier remains small, while the capabilities many production teams want sit on $249 Pro.

Mem0's hosted and open-source editions share the core operations: add, search, get, list, update, delete, delete-all, and history. Both support user_id, agent_id, and run_id scoping, entity-aware ranking, multimodal input, expiration, reranking, custom extraction instructions, Python and JavaScript SDKs, and REST. That common core makes the open-source path more than a demo and gives a team a realistic escape route from hosted infrastructure.

The hosted Platform versus OSS comparison is unusually candid about the boundary. Platform adds app_id tenancy, organizations, projects, a project-wide event feed, native Graph Memory, Memory Decay, Temporal Reasoning, and Dream background consolidation. It also supplies webhooks, categories, schema-driven export, feedback, summaries, and batch update or delete for up to 1,000 memories.

The OSS v3 wall is equally specific. It has no queryable Graph Memory, Memory Decay, Temporal Reasoning, Dream, webhooks, project event feed, memory export, managed feedback, summaries, or batch operations. You can still build a capable memory service, but you must supply the vector store, model, embedder, operations, and the missing policy features yourself. Open source is the control option, not the feature-complete hosted plan for free.

Best for: Product teams embedding user, agent, and run memory into a SaaS or internal application.
Standout: A shared core API across hosted and self-hosted editions, with managed graph, decay, temporal ranking, and consolidation when needed.
Pricing: Hobby is free with 10,000 adds, 1,000 retrievals, and 1 project monthly. Starter is $19/month with 50,000 adds, 5,000 retrievals, and 1 project. Pro is $249/month with 500,000 adds, 50,000 retrievals, unlimited projects, Graph Memory, Dream, analytics, and private Slack. Enterprise is custom with unlimited requests and projects, SLA, on-premises deployment, audit logs, SSO, and custom integrations. Prices verified August 28, 2026 on Mem0's pricing page.
Free trial: The hosted Hobby tier is free and requires no credit card; the open-source edition is also available to self-host.

A Practical Mem0 Starting Pattern

The safest first implementation is narrower than "remember everything." Pick one type of durable fact, keep source text and timestamps, and measure whether retrieval improves a repeated workflow.

1. 1

   Choose one memory contract

   Start with a single object such as approved customer preferences, resolved account constraints, or accepted coding conventions. Define what may be stored, its owner, its expiry condition, and what must never enter memory.

2. 2

   Scope every write

   Attach the correct user, agent, and run identifiers before adding memory. Use hosted app_id only when the application or tenant boundary genuinely needs it. A missing scope is a data-isolation defect, not a later cleanup task.

3. 3

   Retrieve before the expensive step

   Search memory immediately before the decision that benefits from it, then pass only the small relevant result to the model. Do not inject the full memory list into every prompt.

4. 4

   Capture correction and expiry

   Give the host application an explicit path to update, delete, or expire a wrong fact. On Platform, use feedback and the event feed to monitor retrieval quality; on OSS, build that telemetry into the surrounding service.

5. 5

   Promote only on evidence

   Stay on Hobby or Starter until request limits, project isolation, or managed graph and consolidation create a measured constraint. Move to Pro because a named workload earns the $230 premium, not because the prototype reached production.

The quotable verdict: Mem0 is the safest broad default, but its best managed memory features are also the features that turn a $19 experiment into a $249 platform decision. If you only need a few stable preferences, Starter or OSS can be enough. If you need temporal validity, consolidation, project-level operations, and graph-aware ranking, evaluate Pro against Hindsight and Zep before committing.

2. Perplexity Brain: Best No-Build Work Memory

Perplexity Brain is the best choice when the job already happens inside Perplexity Computer and the business wants persistent work context without an engineering project. A strategy lead can reopen a customer project weeks later and let Computer recover prior decisions, files, people, corrections, and open loops. Brain refreshes that working model in the background and links entries back to their sources. The hard wall is portability: this is a Research Preview inside paid Max plans, not a general-purpose memory API for your own agent product.

Brain launched on June 18, 2026 as a self-improving memory system for Computer. According to the launch announcement, it builds a context graph from the work Computer performs and refreshes an LLM wiki at intervals such as overnight. The source material can include sessions, connector results, artifacts, changes in documents, and user corrections. That is closer to an operating memory for knowledge work than a preference field attached to a chatbot.

The current Brain documentation provides several trust controls that matter in practice. Every entry links to a source. Concepts, Entities, and Workstreams appear in a browsable wiki and graph. The user can edit or delete an entry, and a correction feeds the next background run. Brain reinforces what remains true, updates what changed, and marks stale information rather than treating every old fact as equally valid.

Privacy is handled as a product boundary, not an invisible promise. Brain learns only from the subscriber's own activity and excludes incognito sessions. It has a separate on/off toggle, and Enterprise admins can disable it for members. Perplexity says it uses AI-based filtering to reduce the chance that credentials and similar sensitive details enter memory, while Enterprise data is not used for model training. Filtering reduces risk; it is not a substitute for keeping secrets out of source material.

The headline results need careful attribution. Perplexity reports that early measurements on tasks Computer had seen before produced 25% higher answer correctness, 16% higher recall, and 13% lower cost when historical context was required. The test design and raw evaluation set are not exposed on the help page, so these numbers support a promising product result, not a universal claim that Brain beats API memory systems.

Best for: Executives, analysts, operators, and project teams already doing repeat knowledge work in Perplexity Computer.
Standout: Background work memory that connects sessions, files, connectors, artifacts, decisions, and corrections with source links.
Pricing: Brain is available in Research Preview on Consumer Max at $200/month or $2,000/year and Enterprise Max at $325/seat/month or $3,250/seat/year. Enterprise Pro costs $40/seat/month or $400/seat/year but is not eligible for Brain. Consumer Max includes 10,000 Computer credits monthly; Enterprise Max includes 15,000; unused monthly credits do not roll over. Prices verified August 28, 2026 from Perplexity's plan, Enterprise pricing, and credit guide.
Free trial: No Enterprise Pro or Enterprise Max trial is offered; Brain requires an eligible paid Max subscription.

Project ownership deserves its own budget line. Perplexity bills project-level Brain runs to the project creator, even when other people collaborate in that project. For a shared research or account workflow, assign a real owner, decide whether runs should be automatic or manual, and review credit consumption before scaling the contributor list.

The annual discount is meaningful only after adoption. Ten Consumer Max seats save $4,000 per year on annual billing versus twelve monthly payments. Ten Enterprise Max seats save $6,500. A 30-day shadow period should establish whether users actually resume old work, make fewer corrections, and consume fewer historical-context credits before procurement locks the year.

The quotable verdict: Perplexity Brain is the fastest route from forgetful AI work to source-linked operating memory, but the price buys a workspace, not a portable memory layer. Pick it when Computer is the destination. Skip it when your own application, data plane, or model routing must own the memory.

3. Hindsight: Best for Deep Temporal Recall and Reflection

Hindsight is the strongest choice when memory must do more than fetch a similar note. A research agent can retain dated findings, connect people and entities, synthesize observations, and later reason about what changed between two periods. Its TEMPR retrieval combines four signals rather than betting everything on embeddings. The wall is a more complex bill and a more opinionated memory model than simple preference recall needs.

Hindsight organizes the memory loop into three operations. Retain extracts facts, entities, and temporal data into a memory bank. Recall retrieves relevant memory using parallel strategies. Reflect lets an agent reason over that material under the bank's mission, directives, and disposition. The separation is useful because storage, retrieval, and higher-order reasoning have different cost and latency profiles.

Its hierarchy is also explicit. Raw world facts and experience facts sit at the bottom. Observations consolidate patterns with evidence. Mental Models provide curated summaries for common questions. Hindsight checks Mental Models, then Observations, then Raw Facts, so a mature bank can answer recurring questions without rebuilding the same synthesis on every call.

TEMPR stands for the four retrieval paths Hindsight runs together: semantic similarity, BM25 keyword search, graph connections, and temporal reasoning. Exact identifiers benefit from keyword search, related people or projects benefit from graph traversal, and questions such as "what changed last month?" need time-aware retrieval. That blend is the reason to consider Hindsight over a thin vector-store wrapper.

The vendor's benchmark result is notable but should stay in its lane. Hindsight's published BEAM results show a 64.1% score at the 10-million-token tier versus the next published result at 40.6%, with 73.9% at 1 million and 71.1% at 500,000. Hindsight calls the 10-million-token margin 58%. The leaderboard is public, but this article did not reproduce the run, so treat it as vendor-published evidence that deserves your own representative eval.

Best for: Research, account intelligence, personal agents, and long-running workflows where time, contradiction, and reflection matter.
Standout: TEMPR retrieval plus a hierarchy that turns raw facts into evidence-backed observations and reusable mental models.
Pricing: Self-hosting is available without a Hindsight license fee. Hindsight Cloud Pay-As-You-Go charges Retain at $10/MTok input, Recall at $0.75/MTok output, Reflect at $0.05/call, Retrieve Model at $0.25/MTok output, Refresh Model at $0.05/call, Iris file conversion at $7.50/MTok output, and storage older than 30 days at $0.25/MTok/month. Credit packages are $10, $25, $50, or $100, with custom purchases from $5 to $1,000; 1 credit is $1. Enterprise is invoiced with custom volume discounts. Rates verified August 28, 2026 on the Hindsight billing page.
Free trial: The open-source self-hosted path is free; the inspected cloud billing page presents Pay-As-You-Go rather than a timed trial.

The July 6, 2026 pricing change makes older comparisons unreliable. Retain fell from $15 to $10 per million input tokens. Reflect and Refresh Model moved from per-token charges to $0.05 per call. A separate $0.25 per million tokens per month storage line now applies after 30 days. A buying model copied from a spring roundup is therefore wrong even if every feature description remains accurate.

For a 10-million-token historical corpus, the first Retain is $100 and long-term storage is $2.50 per month after the grace window. One hundred Reflect calls add $5. That makes consolidation inexpensive relative to initial ingestion, but repeated re-ingestion will hurt. Deduplicate and version source material before Retain rather than making the memory system clean up a noisy feed.

The quotable verdict: Hindsight earns its complexity when the answer depends on time and synthesis; it is overbuilt for a bot that only needs to remember a preferred name and tone. Choose it after an evaluation set proves that temporal and reflective retrieval change decisions, not because four retrieval modes sound impressive.

4. Zep and Graphiti: Best Governed Temporal Knowledge Graph

Zep is the managed choice for teams that want a temporal knowledge graph with enterprise governance, while Graphiti is the open-source engine for teams willing to assemble the surrounding system. A customer-success agent can preserve account changes as dated facts, invalidate what is no longer true, and retrieve connected context without losing the history. Zep adds users, threads, logs, access policy, retention, and managed scale around that graph. The wall is credit billing on ingestion plus a steep $125 entry to the first paid managed tier.

The Zep versus Graphiti guide draws the product boundary cleanly. Graphiti builds one Context Graph per subject and can run against Neo4j, FalkorDB, or Amazon Neptune. It models facts bi-temporally, invalidates superseded facts, and mixes vector, full-text, and graph retrieval. That is a strong core, but you own deployment, tenant management, monitoring, security, and tuning.

Zep operates Graphiti inside a managed Context Lake and adds proprietary extraction, observations, ranking, embeddings, user and thread storage, visualization, debug logs, and API logs. Governance includes RBAC for team access, ABAC for agent access, audit, retention, tenant isolation, and customer-key encryption. Deployment can be cloud, BYOK, or BYOC at Enterprise. Zep claims sub-200ms smart retrieval at scale; treat that as a vendor claim until your graph shape and region reproduce it.

Zep's billing unit is an Episode, which can be a chat message, JSON payload, or text block. One Episode up to 350 bytes consumes 1 credit; every additional 350 bytes or partial increment adds another. Webhooks cost one-eighth credit. Retrieval, storage, threads, users, and graph storage consume zero credits. That concentrates the variable bill on ingestion and processing rather than read volume.

Best for: Enterprise and growth-stage agents that need changing facts, relationship-aware retrieval, and explicit governance.
Standout: A temporal graph core with a clear open-source-to-managed path and governed tenant controls.
Pricing: Free includes 10,000 credits/month, 2 projects, 1 Memory MCP Server seat, and 5 custom entity and edge types, with no rollover or auto-top-up. Flex is $125/month with 50,000 credits, $25 per additional 10,000, 30-day rollover, and 5 projects. Flex Plus is $375/month with 200,000 credits, $75 per additional 40,000, 60-day rollover, and 10 projects. Enterprise is custom with negotiated credits and rates, guaranteed SLA, unlimited projects, 1-year logs, and cloud, BYOK, or BYOC. Prices verified August 28, 2026 on Zep's pricing page.
Free trial: The Free tier supplies 10,000 credits monthly, but has variable rate limits, lower processing priority, and no rollover.

The most useful estimate starts with bytes, not conversations. Zep's live calculator uses 15,000 Episodes averaging 700 bytes, which consumes 30,000 credits, plus 20,000 webhook calls at 2,500 credits. The 32,500-credit total fits Flex. If your application sends a whole verbose message where a compact event would do, it can double or triple ingestion credits without creating better memory.

The explicit tier flip arrives just above 150,000 forecast credits. Flex plus ten top-ups costs the same $375 as Flex Plus but covers only 150,000 credits. At 160,000 credits, Flex is $400 and Flex Plus is $375 with another 40,000 credits of headroom. That is a budget threshold procurement can monitor rather than a vague instruction to upgrade at scale.

The quotable verdict: Graphiti is for builders who want to own the temporal graph; Zep is for organizations that want to govern it. If your memory is mostly isolated preferences and snippets, the graph and $125 floor are probably unnecessary. If answers depend on relationships that change over time and auditors need to see the boundary, Zep's premium has a concrete job.

5. Supermemory: Best for Multimodal Context and Connectors

Supermemory is the best fit when an agent needs one context layer across conversations, documents, user profiles, and business connectors. A personal assistant can ingest a conversation, connect it to a policy document, and later recover both the relevant passage and the user's evolving profile. Deduplication means unchanged content is not charged again under its SM-token meter. The wall is that fast memory availability, connectors, team access, and deployment controls spread across multiple plan and operation charges.

The Supermemory quickstart presents three retrieval products over one containerTag. Document search returns source chunks for RAG. Memory search traverses extracted facts and related edges. A profile returns a stable and recent summary that can be injected without searching the whole corpus. That separation lets an application ask for documentary evidence, personal memory, or a compact profile rather than forcing one retrieval mode into every turn.

Ingestion is asynchronous. The default dynamic dreaming mode may batch related documents so the extracted memory forms from a coherent group. Setting dreaming to instant processes the document as soon as indexing finishes, but costs one extra operation per document. Instant is useful for setup, debugging, and a workflow that needs memory immediately. Leaving it on for every small production write can create an avoidable operations bill.

Tenant design starts with stable tags and keys. The same containerTag must follow a user or account across writes and reads. Supermemory's scoped API keys can restrict a key to one container and prevent access to billing, account settings, or key creation. That is useful for delegated workers, but the host still has to mint, rotate, revoke, and map keys safely.

The billing definition is favorable for synchronized content. SM tokens are the unique tokens Supermemory actually ingests and embeds. Re-uploading the same document or syncing unchanged content does not rebill those tokens. Plain memory-graph ingestion is $0.005 per 1,000 SM tokens and rich content is $0.010. SuperRAG is $0.001 per 1,000 plain tokens or $0.002 for rich content. Search plus graph costs $0.005 per 1,000 queries, and memory operations cost $0.10 per 1,000.

Best for: Agents that combine conversation memory, files, rich media, user profiles, and SaaS connectors.
Standout: Three retrieval shapes over one tenant scope, with unique-token deduplication and broad connector coverage.
Pricing: Free is $0/month with about $5 usage included. Pro is $19/month with about $20 usage, unlimited storage and users, 2 teammates, and Google Drive, Notion, and OneDrive. Max is $100/month with about $130 usage plus Gmail and Granola. Scale is $399/month with about $600 usage, up to 10 teammates, all listed connectors including GitHub, S3, and Web Crawler, spend caps, SOC 2, HIPAA BAA, and self-hosting. Enterprise has no public price and adds fully air-gapped deployment. Usage rates are listed above. Prices verified August 28, 2026 on Supermemory's pricing page.
Free trial: Free includes about $5 of monthly usage and requires no credit card; qualifying startups and researchers can apply for 3 free months of Scale.

At current usage rates, 10 million plain SM tokens cost $50 to put through the memory graph; rich content costs $100. That looks cheap next to model inference, but a feed of tiny records with instant dreaming can move cost into the operation line. Measure token volume and document count separately. A million tokens delivered as ten files is not the same workload as a million tokens delivered as ten thousand events.

Subscription credits reset monthly. Purchased top-ups do not expire. Free pauses after depletion, while paid plans can auto-top-up; Scale adds hard spend caps. The right production setup therefore uses a stable customId for updated content, default dynamic dreaming for routine feeds, instant only on latency-sensitive writes, and a cap before auto-top-up.

The quotable verdict: Supermemory is the broad context-ingestion pick, not the simplest memory API. Choose it when rich files, connectors, profiles, and deduplicated sync are central to the agent. Skip it when your memory is small, text-only, and better served by a narrower API or a database you already operate.

6. Cognee: Best Open Knowledge Engine for BYOC Teams

Cognee is the best open knowledge-engine choice for teams that want memory represented across graph, vector, and relational stores. A scientific or internal research agent can ingest documents, extract an ontology, refine stale relationships, and retrieve through graph or lexical modes while preserving provenance. Embedded defaults make a local start unusually light. The wall is architectural surface area: a knowledge engine creates more schema, model, database, and evaluation decisions than a small preference-memory service needs.

Cognee's memory pipeline has four named stages. add ingests sources. cognify runs a six-stage process that classifies documents, checks permissions, extracts chunks, uses a model to extract entities and relationships, generates summaries, embeds content, and commits graph edges. memify prunes stale nodes, strengthens frequent connections, reweights edges, and adds derived facts. search retrieves through the resulting structure.

The storage stack explains the engine label. Cognee combines a graph store, vector store, and relational store. Its file-based defaults are Kuzu, LanceDB, and SQLite, so a local prototype does not require a fleet of services. At larger scale, the documented options include Neo4j, FalkorDB, Neptune, Qdrant, pgvector, Redis, DuckDB, Pinecone, ChromaDB, and PostgreSQL.

Fourteen retrieval modes cover graph completion, raw chunks, lexical chunks, summaries, temporal search, Cypher, code-oriented rules, and an automatic selector. That breadth is useful when one memory corpus supports different questions. It also creates an evaluation burden: a team must know which route produces the most faithful answer for each class rather than assuming the automatic mode always wins.

Multi-tenancy is supported across pgvector, Neo4j, Kuzu, and LanceDB. That is important because memory isolation can fail below the agent layer. A perfect user ID in the prompt does not help if the underlying search queries a shared unscoped graph. Tenant tests should verify writes, reads, deletes, and derived facts across every selected backend.

Best for: Teams building domain knowledge engines, using BYOC, or combining ontologies with persistent agent memory.
Standout: An explicit add, cognify, memify, search lifecycle over graph, vector, and relational storage.
Pricing: Free is $0/month with 1 million tokens, 1 workspace, unlimited users and API access, and no card. Standard is $2.50 per 1 million processed tokens plus $5 per additional workspace, with Slack, Notion, Linear, and Google Drive connectors. Enterprise pricing is not public; it is a BYOC engagement offered in Startup, 6-month, 12-month, and 24-month shapes with the customer's cloud, dedicated support, and SLA. Open Source can be self-hosted without a Cognee license fee. Prices verified August 28, 2026 on Cognee's pricing page.
Free trial: Free is a permanent hosted tier with no card; the open-source engine is also available for local deployment.

The cloud arithmetic is attractive at moderate token volume. Ten million processed tokens cost $25 on Standard. If the account also needs three additional workspaces, add $15, for a modeled $40. That does not include model-provider charges, team engineering, or any infrastructure attached to a self-hosted backend. Cognee's low token line should not be mistaken for total cost of ownership.

The best buying signal is an ontology-shaped problem. If your agent repeatedly asks multi-hop questions such as which supplier affects which product and which obligation changed, Cognee's structure can earn its complexity. If every useful memory is a short preference retrieved by user ID, Mem0 or a small application-owned store will reach value faster.

The quotable verdict: Cognee is the memory engine for a team that wants to shape knowledge, not merely save chat history. Choose it when the graph and deployment boundary are deliberate requirements. Skip it when "open source" is being used to avoid a $19 plan but no one owns the resulting stack.

7. Claude Managed Agents Memory Stores: Best for Auditable File-Native Memory

Claude Managed Agents memory stores are the best fit when an agent already runs in Anthropic's managed runtime and durable state should remain small, readable, versioned files. A finance agent can mount a read-only policy store beside a read-write project store, update a decision note, and leave an immutable version trail. The filesystem model is easy for an agent to inspect with ordinary tools and for a host to review out of band. The wall is that this is a public beta with strict object limits and no separate public memory-store price.

Managed Agents sessions are ephemeral by default. A memory store is a workspace-scoped collection of text documents that persists across sessions. When attached through session resources, it appears at /mnt/memory/<store-name>/, and the agent uses ordinary read, write, edit, search, and shell tools instead of a proprietary memory command.

This is closer to durable working files than automatic semantic memory. The host can seed a store with standards or project context. A session can mount it as read-only or read-write. Writes persist back to the store. Every mutation creates an immutable version with an operation record, enabling audit, point-in-time rollback, and redaction. Optimistic concurrency can prevent one writer from silently overwriting another's fresh update.

The limits shape the design. Each memory document can be no larger than 100KB. A session can attach at most 8 stores, and stores attach only when the session is created. Archiving is irreversible: the store becomes read-only, cannot attach to new sessions, and cannot be unarchived, although existing session attachments continue. These constraints favor many small, purpose-specific documents over one giant memory dump.

The security warning is blunt and valuable. Do not put credentials, API keys, or tokens into a memory store. Stored content can return verbatim to later sessions that mount it. Anthropic directs builders to vault environment-variable credentials instead. If a secret enters memory, deleting the current file is not enough; affected immutable versions must be redacted.

Best for: Anthropic Managed Agents that need inspectable project, policy, or user documents across sessions with an audit trail.
Standout: Readable filesystem mounts plus immutable versions, rollback, redaction, and read-only or read-write access.
Pricing: Anthropic does not publish a separate memory-store line in the inspected beta documentation. Model and runtime usage apply. Claude Sonnet 5 is $2/MTok input and $10/MTok output; Claude Opus 4.8 is $5/MTok input and $25/MTok output. Prices verified August 28, 2026 from Anthropic's Sonnet 5 announcement.
Free trial: Memory stores are in public beta under the managed-agents-2026-04-01 header; no separate free tier or timed store trial is published.

The cost benefit comes from selective file access, not from free persistence. At Sonnet 5's published rate, resending a 100,000-token brief in 100 sessions creates 10 million input tokens, or $20 before cache adjustments. A mounted store lets the agent read the one relevant note, but careless instructions can still make it open every file. Profile file reads in representative sessions before claiming savings.

The Agent object and the memory store should also remain separate in your operating model. Anthropic's Managed Agents overview says the versioned Agent configuration is created once and reused across sessions. The memory store holds learned or project state. Updating a system prompt should create a new Agent version; correcting a customer fact should update memory. That separation makes regressions and deletions traceable.

The quotable verdict: Claude memory stores are excellent governed working files, not a turnkey cognitive memory layer. Choose them when auditability and file semantics are the advantage. Add a retrieval or consolidation layer when the store grows beyond what an agent can navigate reliably.

8. Letta: Best Portable Memory for Coding Agents

Letta is the best pick when a coding agent's identity and memory should outlive the model provider underneath it. A codebase agent can initialize from repository context and prior Claude Code or Codex sessions, refine its memory as it works, then switch models without abandoning that identity. The new direction is open, model-agnostic, and file-native. The wall is transition risk: Letta is actively replacing several older server-side memory patterns, so tutorials and integrations can become stale quickly.

The Letta Code application can start blank or initialize memory with /init, drawing from the current codebase and past Claude Code or Codex sessions. Memory subagents periodically review sessions, rewrite context, and refine memory. /doctor cleans and reorganizes what accumulated. Those maintenance paths matter because persistent memory without pruning becomes a larger, less reliable prompt in slow motion.

Portability is the product thesis. Letta decouples the agent's memory and identity from the underlying model provider, so a user can switch models even during a session while retaining context, memory, and personality. The app accepts a user's own API keys or eligible coding plans. It is available on macOS, Windows, and Linux, which makes it a practical local entry rather than only an SDK concept.

The current architecture direction is more important than old Letta mental models. In Letta's next-phase announcement, memory moves from specialized database-editing tools into git-backed context-repository files called MemFS. General filesystem tools replace legacy server memory tools. Client-side skills and subagents replace several hardcoded server mechanisms. That makes memory more inspectable and portable, but it also creates migration work.

Letta says legacy server memory tools are being removed, while templates and the former filesystem were scheduled for deprecation by mid-April 2026. A production evaluation must start from the current Code and context-repository path, not a copied example using core_memory_replace or a sleep-time server agent. The transition is a decisive con even if the destination architecture is attractive.

Best for: Coding agents and personal developer agents that need model-portable memory, identity, skills, and sessions.
Standout: Git-backed context repositories plus memory subagents, /init, and /doctor in a model-agnostic agent harness.
Pricing: Letta Code is free to get started and uses your own model API keys or supported coding plans; model usage and self-hosting remain separate costs. The current Letta pricing URL inspected on August 28, 2026 returned 404, so no managed-cloud tier price is safe to publish. Letta's documentation offers a managed Letta Cloud path and a complete self-run App Server runtime.
Free trial: Free application and open-runtime entry; no verified timed managed-cloud trial is stated here.

The economic case is strongest when model optionality has real value. If a team changes coding models quarterly, preserving one agent's conventions, project map, and past-session lessons can avoid repeated setup. If the company has standardized on one managed agent platform and needs strict tenant APIs, portability may be less valuable than Mem0's application model or Claude's workspace controls.

Treat the context repository like production state. Review diffs, keep secrets out, assign ownership for corrections, and decide which files can be rewritten by the agent. Git history is useful evidence, but it does not automatically create consent, retention, or tenant policy. A portable memory with no deletion owner is still an operational liability.

The quotable verdict: Letta is the most compelling memory choice for a coding agent that should survive model churn, but its current migration makes version awareness part of the purchase. Use the new file-native path. Avoid any design whose critical behavior depends on a legacy server tool Letta has already marked for removal.

9. LangMem: Best Library-First Memory for LangGraph

LangMem is the best library-first option for a LangGraph team that wants to design its own memory policy instead of buying a hosted memory product. An agent can write and search memories during an active conversation, while a background manager extracts and consolidates knowledge after the turn. Its core works with any storage system and integrates with LangGraph's store layer. The wall is easy to miss: the quick example's in-process store loses everything on restart, so durable production memory still needs a real database and operating discipline.

The LangMem repository provides functional primitives rather than a complete hosted service. Hot-path tools let an agent decide when to record or search memory during a conversation. A background manager extracts important facts, consolidates duplicates, updates knowledge, and can refine prompts. The library can use LangGraph's native store or another storage implementation.

That flexibility is the reason to choose it. A team can define semantic memory for user facts, episodic memory for past actions, and procedural memory in prompt or policy updates without accepting another vendor's fixed schema. It can also keep extraction outside the latency-sensitive turn. The cost is that your team owns the schema, model calls, retrieval behavior, consolidation schedule, evaluation, database, and deletion semantics.

The production warning appears in the official example. InMemoryStore keeps data in process memory and loses it on restart. The documentation recommends AsyncPostgresStore or a similar database-backed store for persistence. A demo that remembers across two calls in one process has not proven cross-session durability. Restart the process in the acceptance test.

Best for: LangGraph developers who want custom memory behavior and already own a reliable database and evaluation loop.
Standout: Hot-path memory tools and background extraction or consolidation that work with any compatible store.
Pricing: LangMem itself is MIT licensed and free. Optional LangSmith Developer is $0/seat/month with 1 seat and 5,000 base traces/month, then usage. Plus is $39/seat/month with unlimited purchasable seats, 10,000 base traces/month, and 1 small serverless deployment, then usage. Enterprise is custom with self-hosted and hybrid options. LangSmith usage is metered at $1.50 per LCU and $1.00 per LSU. Prices verified August 28, 2026 on LangChain's pricing page.
Free trial: The library is free and open source; optional LangSmith has a $0 Developer plan rather than a timed trial.

LangMem is cheapest only when the team already has the surrounding capabilities. The package fee is $0, but a reliable Postgres store, migrations, background workers, model extraction, traces, and on-call ownership are not. Compare that labor with Mem0 Starter or Pro, not with zero. A five-person team using LangSmith Plus begins at $195 per month before traces, compute, storage, model calls, and the memory database.

The library pairs naturally with an agent that needs both history and live evidence. LangMem can retain prior conclusions, but current prices, laws, schedules, and outside events should come from a live retrieval layer such as the options in this guide to AI search APIs for autonomous agents. Memory should recall the last decision and its assumptions; search should verify what may have changed.

The quotable verdict: LangMem is a set of sharp memory primitives, not outsourced memory operations. Choose it when customization is the reason and LangGraph is already your runtime. Skip it when the team wants a service-level outcome and is treating an in-process example as durable architecture.

Who Should Pick What

The fastest decision comes from the workflow boundary, not a global score.

Pick Perplexity Brain for a managed knowledge-work seat

Use Brain when analysts, founders, or account teams already rely on Perplexity Computer and repeat work across the same projects. It buys back recap and source-hunting without a build. The choice flips away from Brain when memory must power your application, cross a vendor boundary, or expose a neutral API.

Pick Mem0 for the broad application default

Use Mem0 when a SaaS or internal app needs per-user and per-agent memory and the product team wants a hosted start with a self-hosted option. It remains the default until temporal reasoning, an enterprise graph, rich connector ingestion, or file-native audit becomes the dominant requirement. Watch the $19 to $249 jump and prove that hosted-only features earn it.

Pick Hindsight when questions depend on time and synthesis

Use Hindsight for long histories where exact terms, relationships, time, and higher-order observations all affect the answer. It is the right candidate when a representative evaluation shows simple semantic retrieval missing changed facts or recurring synthesis. The choice flips back to Mem0 or a smaller store when reflection does not improve decisions enough to justify the Retain and storage model.

Pick Zep for a governed temporal graph

Use Graphiti when you want to own the temporal graph and Zep when governance, logs, managed users, tenant isolation, and deployment options matter. Zep becomes economically attractive above 150,000 forecast monthly credits relative to repeated Flex top-ups. The choice flips away when a graph is not central or when compact preference records do not need temporal relationship modeling.

Pick Supermemory for rich context ingestion

Use Supermemory when the memory corpus mixes conversations, files, media, profiles, and synced SaaS sources. Its unique-token billing is attractive for unchanged synchronized content. The choice flips to a narrower API when document count and instant operations create more cost and complexity than the multimodal layer removes.

Pick Cognee when the ontology is the product

Use Cognee when relationships, provenance, BYOC, and multiple retrieval modes are core to the application. It fits teams prepared to own graph and database choices. The choice flips to a managed memory API when the engineering group does not have an explicit owner for ontology, retrieval evaluation, and backend operations.

Pick Claude memory stores for auditable working files

Use Claude Managed Agents memory stores when durable state should be readable files with version history, access modes, rollback, and redaction. The choice flips to a semantic memory service when the collection becomes too large or relational for file navigation and manual structure.

Pick Letta for a model-portable coding agent

Use Letta when the agent's learned repository map, conventions, identity, and sessions must survive model changes. The choice flips away when the organization values a stable managed platform more than portability or cannot absorb Letta's active migration.

Pick LangMem for custom policy inside LangGraph

Use LangMem when the team wants to define memory types, write policy, extraction, consolidation, and storage. The choice flips to a service when that ownership is incidental work rather than product differentiation.

The general flip rule is simple: managed wins when the monthly premium is lower than the ongoing engineering and risk cost of operating memory; open or self-hosted wins when data location, inspection, or behavior cannot be delegated. Include correction volume in that calculation. A system that retrieves cheaply but creates one hour of weekly cleanup per customer can be the most expensive option on the page.

The Ones to Avoid

Avoid buying the label "memory" without checking the persistence test. A system should survive a new session or process restart, retrieve selectively, accept correction, and support deletion within the right tenant boundary. These are the specific traps most likely to fail that test.

LangGraph InMemoryStore as production persistence

InMemoryStore is useful for LangMem examples and local development. The official LangMem documentation says its contents are lost on restart. Do not ship it as durable memory, even if a demo remembers across several calls. Use a database-backed store such as AsyncPostgresStore and include a real process restart in acceptance testing.

Pinecone, Qdrant, or another vector database presented as the entire memory system

These can be excellent storage and similarity-search components. Avoid the claim that adding embeddings alone has solved memory. A complete design still needs extraction, temporal validity, contradiction handling, tenant isolation, correction, provenance, retention, and deletion. Build those layers intentionally or choose a system that supplies them.

Perplexity Brain for a portable multi-tenant application

Brain is compelling inside Computer, but it is not the right foundation for a SaaS product that needs its own memory API, tenant keys, model routing, and exportable policy. The seat price buys an integrated work environment. Avoid forcing a no-build workspace into a developer-platform job.

Graphiti without an operator

Graphiti gives a team a capable temporal graph core. It does not remove graph storage, deployment, monitoring, security, scaling, or retrieval-evaluation work. Avoid self-hosting it merely to escape Zep's $125 Flex price if no engineer owns the resulting service.

Stale Letta server-memory tutorials

Avoid designs built around legacy server tools such as core_memory_replace, former filesystem behavior, or sleep-time server agents. Letta has publicly described their removal or replacement. Start with Letta Code, context repositories, filesystem tools, and current SDK guidance.

Any memory product with no correction and deletion owner

Even a technically strong system becomes unsafe when nobody owns bad memory. Automated consolidation can turn one mistake into a confident summary. Before rollout, name who can inspect a source, correct a fact, redact a secret, delete a tenant, and verify downstream copies. If the vendor cannot support that lifecycle, skip it for consequential workflows.

The Monday Move

Do not migrate an entire knowledge base on Monday. Pick one repeated workflow where old context clearly matters, such as preparing a weekly account brief, continuing a coding task, or applying a customer's approved operating preferences.

1. Write the memory contract. List the one fact class that may persist, its tenant key, source, expiry rule, and prohibited data. Keep secrets out.
2. Build a shadow path. Let the current agent answer normally while the candidate memory system retrieves in parallel. Store the retrieved context and outcome without silently changing production decisions.
3. Create 20 historical questions. Include changed facts, exact names, old-versus-new decisions, deletion requests, and one deliberately wrong memory. A generic benchmark cannot replace this set.
4. Measure four outcomes. Track answer correctness, tokens or credits used, human recap time, and correction rate. Include latency, but do not let a fast wrong answer win.
5. Exercise the lifecycle. Restart the process, open a new session, change a source fact, revoke a tenant, delete a record, and verify that stale copies stop appearing.
6. Price the steady state. Apply the vendor's actual meter to one month of writes, reads, storage age, operations, seats, and expected growth. Add the operator time for open-source options.
7. Set the flip threshold. Record the exact usage, governance, or quality condition that justifies the next tier or a different system.

For Mem0, that may be the move from Starter to Pro when graph, consolidation, or request capacity earns $230 more each month. For Zep, it is a forecast above 150,000 credits where Flex Plus becomes cheaper. For Perplexity, it is enough repeated Computer work to justify a $200 or $325 seat. For LangMem, it is a team willing to own the database and memory policy instead of treating free software as free operations.

At the end of the week, promote only one workflow. A successful memory rollout is not the largest corpus ingested. It is a smaller repeated task that resumes cleanly, uses less repeated context, produces fewer corrections, and can forget on command.

Frequently Asked Questions

Which AI memory systems for agents are available on GitHub?

Mem0, Hindsight, Graphiti, Cognee, Letta Code, and LangMem all provide open-source paths. Open source does not mean equivalent capabilities: Mem0 keeps several v3 ranking and operations features on Platform, Graphiti requires you to build governance around the graph, and LangMem requires a durable store and surrounding operations.

What is an agent memory framework?

An agent memory framework is the layer that decides what an agent stores, how that state is organized and corrected, and which relevant portion returns to a future session. It usually combines persistence, extraction, retrieval, and lifecycle policy rather than only saving raw chat transcripts.

Is a vector database enough for AI agent memory?

No, not by itself. A vector database can persist embeddings and retrieve similar content, but a production memory design also needs tenant scoping, temporal validity, contradiction handling, provenance, correction, retention, and deletion. It can be the storage component underneath a complete memory system.

Does a larger context window replace persistent memory?

No. A larger window holds more material during one inference, but it does not decide what survives a new session, what became stale, who owns a fact, or how to delete it. Selective persistent retrieval also avoids resending the whole history on every run.

When should I choose Mem0 instead of Hindsight or Zep?

Choose Mem0 as the broad application default. Choose Hindsight when temporal recall, parallel retrieval, observations, and reflection are the main quality drivers. Choose Zep when a temporal relationship graph plus RBAC, ABAC, audit, retention, and managed tenant isolation is the requirement.

What is the cheapest persistent memory system for an AI agent?

Several tools start free, but the cheapest depends on the meter and your operating model. Cognee Standard processes 10 million tokens for $25 before workspaces and other costs, Supermemory prices 10 million plain unique SM tokens at $50 for its memory graph, and Hindsight Retain costs $100 for 10 million input tokens. Those units perform different work, while self-hosted software adds model, database, infrastructure, and labor costs.

How should an AI agent forget data?

Use an explicit host-controlled path for correction, expiry, deletion, and redaction, scoped to the same tenant keys used on write. Then test downstream behavior after deletion. Removing one current record is insufficient if immutable versions, summaries, graph edges, caches, or exported copies can still return it.

Want the persistence, deletion, and cost questions in one working sheet? Download the AI Business Workflow Audit Checklist and score one memory workflow on Monday.