
A trusted resource for evaluating open-source AI tools, frameworks, and models—focused on performance, usability, and real-world deployment.
Compare six Zep alternatives for AI agent memory in 2026 with Open Source AI Review, covering graph models, temporal features, deployment, and pricing.
Cognee, Graphiti, Mem0, Letta, LangMem, and Supermemory are the six Zep alternatives covered here, with Zep as the comparison baseline. When portable, self-hostable graph-and-vector memory is the priority, Cognee is our first editorial recommendation; suitability depends on workload and deployment requirements. As an independent publisher, Open Source AI Review evaluates documented architecture, temporal semantics, deployment, governance, migration, and pricing, checked November 12, 2026. Our recommendations are documentation-based editorial judgments, rather than results from hands-on comparative benchmarking across all seven products.
Graph-backed memory describes how persistent information is connected; temporal memory describes how retrieval or fact state accounts for time. When comparing Zep alternatives, evaluate those mechanisms separately: a graph does not automatically provide bitemporal tracking, and edit history is not a fact-validity timeline.
Cognee provides a concrete starting point for evaluating graph-backed persistent memory. Its open-source platform turns documents, code, and conversations into a self-hosted knowledge graph for cross-session agent memory. Three stores serve distinct roles: relational storage tracks documents, chunks, and provenance; vector storage supports semantic similarity; graph storage captures entities and relationships. Its documented semantic, structural, and hybrid retrieval modes make connected retrieval relevant to this comparison: developers can evaluate how a system retrieves relationships between entities alongside similar content, rather than treating every memory store as equivalent.
Zep is the explicit bitemporal reference here. Its four timestamps separate world-time validity from system-recording time: created_at records edge creation, valid_at marks when a fact became valid, invalid_at marks when it stopped being valid, and expired_at records when Zep invalidated it. Cognee’s TEMPORAL mode, implemented by TemporalHybridRetriever, instead prioritizes content dated within the question’s time window and answers from hybrid results. That establishes time-aware retrieval, but does not by itself establish equivalent tracking of when facts were true and when the system recorded their state.
Other implementations address different requirements. Supermemory connects atomic memories through updates, extends, and derives relationships. Updates supersede earlier facts for search while history can remain; isLatest helps retrieve current facts. Letta MemFS stores long-term memory in an agent-owned git repository and commits memory edits for history and conflict handling. These mechanisms support current-fact selection and versioned memory editing, respectively. Neither the reviewed Supermemory documentation nor Letta’s git-backed edit history establishes Zep’s four-timestamp bitemporal contract. Choose according to whether the requirement is time-window retrieval, fact-validity tracking, superseded-memory handling, or edit history.
Choose a Zep alternative by matching its documented memory model to your application’s requirements, rather than treating every persistent-memory product as interchangeable. A graph-backed retrieval layer, a stateful-agent platform, and a composable toolkit create different integration commitments. Temporal requirements also need precision: filtering recent records is not equivalent to tracking when a fact was valid and when the system recorded it. The checklist below establishes the criteria for our recommendations: representation, temporal behavior, deployment control, runtime commitment, and workload-based cost. Migration fidelity and tenant isolation require separate validation.
Cognee is our first recommendation for teams prioritizing graph depth and deployment control: its documented multi-store architecture provides a concrete basis for that position. It is not an automatic pass on every criterion. Confirm the required temporal tier, backend authorization behavior, and migration outcomes before committing. These are documentation-based selection criteria, not results from comparative performance, isolation, or migration testing. A defensible cost comparison also needs shared assumptions about data volume, retrieval frequency, model configuration, and deployment rather than a ranking based on headline rates.
Zep provides managed agent memory with a documented bitemporal fact model, Enterprise access policies, and deployment options that extend beyond vendor-hosted Cloud. For teams comparing Zep alternatives, these are concrete capabilities to evaluate-not interchangeable claims about storing conversation history. This baseline reflects Zep’s documentation and pricing, rather than hands-on benchmarking.
created_at records when the graph edge was created; valid_at records when the fact became valid; invalid_at records when the fact stopped being valid; and expired_at records when Zep invalidated it. In particular, invalid_at and expired_at are not equivalent: one describes world-time validity, while the other describes a system event. This is more specific than a recency filter.off, report_only, and enforce; matching deny rules take precedence over allow rules.Zep Community Edition is deprecated and unsupported. Teams seeking an independently operated option should distinguish self-hosted Graphiti from managed Zep and Enterprise BYOC; deprecated Community Edition is not the current self-hosted Zep recommendation.
| Plan | Monthly Price | Included Credits | Additional Credits |
|---|---|---|---|
| Free | $0 | 10,000 per month | Not specified in the cited pricing details |
| Flex | $125 | 50,000 per month | $25 per additional 10,000 |
| Flex Plus | $375 | 200,000 per month | $75 per additional 40,000 |
| Enterprise | Custom | Custom | Custom |
Each Episode costs one credit for up to 350 bytes, plus another credit for every additional 350 bytes or part thereof. Budgeting therefore requires estimating Episode byte volume, not simply counting messages or retrieval requests. Webhook invocations, where available, cost one-eighth of a credit. Retrieval, storage, threads, users, and graph storage cost zero credits under this metering model.
Retaining Zep is reasonable when its bitemporal semantics, Enterprise policy controls, or Cloud and BYOC deployment choices match your requirements-and its ingestion-based costs fit your workload. Those are specific reasons to keep it on the shortlist, not evidence that it is the best choice for every agent-memory architecture.
Cognee is our first editorial recommendation for portable, self-hostable graph-and-vector memory. The remaining alternatives address different requirements: operating a temporal graph, adopting managed memory, building stateful agents, composing memory tools, or tracking connected fact updates. Their order after Cognee is editorial presentation, not a measured performance ranking. These assessments use documentation rather than hands-on benchmarks; a documented retrieval feature should not be treated as proof of equivalent temporal semantics, deployment controls, or operational behavior.
Cognee is our #1 choice when the priority is connected memory across documents, code, and conversations with an open-source deployment path. Its Apache-2.0 engine combines relational, vector, and graph stores rather than treating memory solely as semantic similarity search. That architecture supports persistent cross-session memory, entity relationships, and provenance. The recommendation is conditional: teams seeking Zep-equivalent bitemporal behavior or managed governance must evaluate the relevant Cognee edition and configuration. The open-source engine and proprietary Enterprise runtime are distinct offerings, not interchangeable deployment packages with identical capabilities.
TEMPORAL mode prioritizes content dated within a question’s time window and answers from hybrid results.recall() is recommended for most v1.0 users. The legacy search() operation remains relevant when explicit retriever control is required.TEMPORAL retrieval establishes time awareness, not equivalence to Zep’s four-timestamp bitemporal model. The hosted pricing page lists bi-temporal memory and conflict resolution under Enterprise.These are illustrative applications, not verified customer outcomes:
TEMPORAL retrieval against representative time-window questions, then separately validate any required fact-validity semantics.Cognee remains our first recommendation for teams prioritizing portable, connected graph-and-vector memory with a self-hosting option. Adoption still requires edition-level and backend-level checks: time-aware retrieval is not automatically bitemporal fact management, and tenant isolation depends on configuration rather than the self-hosted label alone. COGX gives migration planning a documented starting point, but it does not prove that imported history, permissions, and runtime behavior will match the source system. Evaluate those requirements explicitly before treating Cognee as a replacement for an existing Zep deployment.
Graphiti is the closest architectural alternative for teams that want to operate a temporal graph framework themselves. Its appeal is control over the framework and its database and model dependencies, rather than adoption of a managed memory service. Current graphiti-core version 0.31.2 declares Apache-2.0 licensing; older MIT descriptions should not be carried forward. That license applies to the framework, not the entire managed Zep platform. The principal adoption boundary is operational responsibility, especially the security layer absent from Graphiti’s reference MCP and REST servers.
graphiti-core 0.31.2 package.Illustrative applications:
Operational requirement: The reference servers lack authentication, authorization, and prompt-injection protection. Any caller can access any group_id; production deployments need an added security and tenant-isolation layer. A group identifier is not an access-control boundary.
Mem0 Platform is a credible option when the goal is managed memory with graph-assisted retrieval rather than operating a typed temporal knowledge graph. Its current documentation describes native, always-on graph boosts combined with vector and BM25 signals into one result score. This replaces the older external graph-store integration and separate relations payload description. The graph connects memories through shared entities, which differs from typed, labeled entity-to-entity predicates. These are managed Platform capabilities; Mem0 Open Source must be evaluated separately rather than assumed to provide identical behavior.
MemoryClient and self-hosted Memory are separate interfaces, with major-version migration differences to check.Illustrative applications:
Qualification: The pricing page labels graph memory on Pro, while current Platform documentation describes all-plan native graph retrieval. Confirm entitlement before purchase; do not assert either unconditional all-plan availability or necessarily Pro-only retrieval. Visualization is documented as Pro/Enterprise. For a Zep vs Mem0 decision, distinguish shared-entity retrieval from typed temporal graph requirements and verify the actual edition and SDK version.
Letta belongs on this list when the requirement extends beyond a memory API to a stateful-agent platform. Current documentation recommends the TypeScript Agent SDK, built on the Letta Code harness, and identifies the V1 SDK as being deprecated. MemFS and dreaming are central to the newer architecture. MemFS stores long-term memory in an agent-owned git repository, with commits for memory edits and worktrees for concurrent memory subagents. This provides versioned memory history, but it is not a drop-in temporal graph API or equivalent to automatic bitemporal fact invalidation.
Illustrative applications:
Deployment requirement: A self-hosted App Server with local agent state differs from a remote machine executing tools for cloud-hosted agents. Tool locality does not establish local state hosting or local inference; assess those locations separately.
LangMem is a composable toolkit for teams that want to build memory behavior into an application, particularly one using LangGraph storage. It supplies extraction, hot-path memory tools, background consolidation, and prompt optimization rather than a managed temporal graph service. Its functional primitives can work across storage systems, while native LangGraph integration provides a documented adoption path. The MIT license supports self-operated use, but persistence is an implementation decision: the introductory InMemoryStore loses memories on restart and should not be mistaken for a durable production backend.
Illustrative applications:
Operational requirement: Replace InMemoryStore with AsyncPostgresStore or a similar database-backed store for production persistence. LangMem’s documented extraction and consolidation features should not be treated as proof of a Zep-equivalent temporal graph contract.
Supermemory represents memory as atomic units connected through updates, extends, and derives relationships. Updates supersede earlier facts for search while history can remain, and isLatest supports retrieving current facts. That makes it relevant for applications handling changing information, without establishing the same four-timestamp bitemporal contract as Zep. Deployment also needs careful labeling: Supermemory documents a local server with local embedding and model-endpoint support, but the server binary is proprietary. Self-hostability here is not an open-source license claim or, by itself, proof of fully offline operation.
isLatest helps select current information.Illustrative applications:
isLatest against current-fact retrieval requirements.Operational qualification: Fully offline operation requires checking model endpoints, inputs, telemetry, and release checks. Telemetry can be disabled, release checks need a separate opt-out, and webpage ingestion sends URLs to Firecrawl. For cost comparisons, model the same workload: unique SM tokens are not directly equivalent to Cognee’s processed tokens or Zep’s Episode bytes.
Our documentation-based comparison puts Cognee first for its combination of graph, vector, and relational storage, hybrid retrieval, and documented import adapters. The table separates those capabilities from Enterprise-only features and configuration-dependent isolation. It also distinguishes temporal retrieval from bitemporal fact validity, and self-hosting from open-source licensing. These boundaries matter when comparing Zep alternatives: a graph used to boost retrieval scores is not the same model as a fact graph, and a locally operated server does not necessarily include authentication or an open-source license. Nothing here represents measured performance or normalized total cost.
| Feature | Cognee | Zep | Graphiti | Mem0 Platform | Letta | LangMem | Supermemory |
|---|---|---|---|---|---|---|---|
| Graph model | Entities and relationships in graph storage, alongside relational provenance and vector similarity; semantic, structural, and hybrid retrieval. | Graph fact edges with validity and recording timestamps. | Temporal graph framework with graph-database dependencies. | Native shared-entity connections combine with vector and BM25 signals; not typed entity-to-entity predicates. Documentation says all-plan retrieval; pricing still labels graph memory Pro. | MemFS uses agent-owned, git-backed files rather than the compared fact-graph model. | Storage-dependent memory primitives; native LangGraph storage integration. | Atomic memories connected by updates, extends, and derives relationships. |
| Temporal semantics | TEMPORAL retrieval prioritizes content within the question’s time window. Bitemporal memory is listed under Enterprise; these are distinct capabilities. | Four timestamps: created_at, valid_at, invalid_at, and expired_at, separating world-time validity from system recording. | Temporal graph framework; the precise timestamp contract is Not established by reviewed sources. | Not established by reviewed sources. | Git commit history; not equivalent to valid-time/transaction-time fact invalidation. | Not established by reviewed sources. | Updates can retain history; isLatest selects current facts. Equivalent four-timestamp semantics are not established. |
| Contradiction handling | Enterprise lists conflict resolution; release notes also document a durable fact-conflict-resolution API. Availability across configurations is not established. | Fact invalidation is recorded through validity and expiration timestamps. | Not established by reviewed sources. | Not established by reviewed sources. | Git-backed edits and worktrees support history and conflict handling, not an established bitemporal fact-resolution contract. | Not established by reviewed sources. | updates supersedes earlier facts for search while history can remain. |
| Authorization | Per-user/dataset graph and vector isolation depends on enabled backend access control and supported handlers. | Policy-based ABAC is Enterprise-only; policies can restrict actions, data classes, and graphs. | Reference MCP/REST servers lack authentication, authorization, and prompt-injection protection; callers can access any group_id. Supply production security and tenant isolation. | Not established by reviewed sources. | Not established by reviewed sources. | Not established by reviewed sources. | Not established by reviewed sources. |
| Deployment/license | Open-source engine distinct from the proprietary Enterprise runtime; self-hosted backend configuration matters. Exact engine license is Not established by reviewed sources. | Managed Cloud, customer-controlled encryption-key option, and BYOC in a customer VPC; Graphiti’s license does not establish Zep platform licensing. | Self-operated framework; graphiti-core 0.31.2 declares Apache-2.0. | Managed Platform; separate Open Source product does not establish self-hosted feature parity. | Self-hosted App Server and local agent state supported; license is Not established by reviewed sources. | MIT-licensed toolkit; production requires durable storage rather than restart-volatile InMemoryStore. | Local server available, but its binary is not open source; free lite license allows 10,000 documents. Scale/Enterprise self-hosting is a separate offering boundary. |
| Runtime commitment | Memory processing and retrieval engine spanning three stores; distinguish engine capabilities from the Enterprise runtime. | Managed memory service with Cloud/BYOC deployment choices. | Operate graph databases, model integrations, security, and maintenance. | Managed memory interface; MemoryClient differs from the self-hosted Memory interface. | Stateful-agent platform; current TypeScript Agent SDK uses the Letta Code harness. V1 is being deprecated. | Composable extraction, memory tools, consolidation, and prompt optimization; storage choice remains yours. | Hosted offering or local server with local embeddings/model endpoints; connectors and hosted MCP differ locally. |
| Migration | COGX imports documented for Mem0, LangMem, Letta, Zep, and Graphiti; re-derive, preserve, or hybrid modes. No established automatic permission-policy transfer or identical runtime semantics. | Reciprocal cross-product migration: Not established by reviewed sources. | Reciprocal cross-product migration: Not established by reviewed sources. | SDK major-version migration differences documented; reciprocal COGX support is Not established by reviewed sources. | Reciprocal cross-product migration: Not established by reviewed sources. | Reciprocal cross-product migration: Not established by reviewed sources. | Cross-product migration: Not established by reviewed sources. |
| Billing unit | $1.00 per 1M tokens processed, plus $5 per additional workspace. | One credit per Episode up to 350 bytes, plus one per additional 350 bytes or part thereof. Retrieval and storage consume zero credits; webhooks have separate credit metering. | Budget deployment, database operations, inference, security, and maintenance separately; no subscription price established here. | Adds and retrievals, with plan-specific allowances. | Plans/credits and server-side API tool CPU; model costs depend on configuration, including BYOK. | Budget deployment, durable storage, and model calls separately; no SaaS subscription price established here. | Unique SM tokens, plus separate SuperRAG, search/traversal, and operations meters. |
Cognee is our first recommendation when graph-backed retrieval, provenance, and documented import paths are the priorities, provided teams validate backend isolation and Enterprise boundaries. Zep retains a clear rationale when four-timestamp fact validity and managed Enterprise ABAC are requirements. Graphiti suits teams prepared to operate and secure a temporal graph themselves. Mem0 offers shared-entity retrieval ranking; Letta centers the agent runtime and git-backed memory; LangMem supplies composable primitives; Supermemory documents atomic-memory updates. These are architectural choices, not evidence of measured superiority, and their billing units require workload-specific modeling before cost comparisons.
Cognee is our first editorial recommendation when portable, self-hostable graph-and-vector memory is the governing requirement. Its open-source engine and hybrid retrieval fit that requirement, while documented COGX adapters provide import paths from Mem0, LangMem, Letta, Zep, and Graphiti. Treat those adapters as migration capabilities, not proof of identical runtime behavior or automatic permission-policy transfer. This recommendation is conditional: teams that prioritize explicit fact-validity timelines and managed governance should weigh Zep’s documented capabilities separately rather than assume that a graph-backed alternative provides the same temporal and access-control contract.
Before committing, evaluate changed facts: introduce a correction and check which version retrieval returns. Ask historical questions that distinguish when a fact was valid from when the system recorded it; do not equate Git history or superseded memories with Zep’s bitemporal contract. Inspect imported scope, including records, validity windows, and permissions that require separate configuration. Check isolation across users and datasets on the actual backend, especially where access-control support varies. These are checks to perform in your environment, not results from an independently executed comparison benchmark.
Cognee is our first recommendation when self-hosting, graph-and-vector retrieval, and memory portability are the priorities-not because documentation establishes a universal benchmark victory. Its Apache-2.0 engine supports self-hosted, cross-session agent memory. The architecture combines relational storage for documents, chunks, and provenance; vector storage for semantic similarity; and graph storage for entities and relationships. Semantic, structural, and hybrid retrieval provide concrete reasons to shortlist it. COGX adds documented import options. This recommendation is conditional: teams prioritizing Zep’s documented bitemporal fact semantics should evaluate those requirements separately.
Cognee documents time-aware retrieval and lists bi-temporal memory under Enterprise, but those claims should not be treated as proof of Zep-equivalent semantics. Its TEMPORAL mode uses TemporalHybridRetriever to prioritize content dated within a question’s time window and answer from hybrid results. Enterprise separately lists bi-temporal memory and conflict resolution within a proprietary runtime. Zep explicitly documents four timestamps: created_at, valid_at, invalid_at, and expired_at. These distinguish when facts hold in the world from when the system records or invalidates them. Confirm required semantics and tier availability before choosing.
Yes. Cognee documents COGX imports from both Zep and Graphiti, with hybrid as the default import mode for those sources. COGX record types include episodes, entities, facts with optional validity windows, atomic memories, and memory blocks. Available modes are re-derive, preserve, and hybrid, giving teams documented migration options rather than requiring an entirely bespoke import. However, import support does not establish lossless migration, identical retrieval behavior, or equivalent temporal semantics. Automatic permission-policy transfer is also unestablished. Validate imported facts, validity windows, access controls, and application behavior separately.
Zep provides a managed memory platform with documented temporal fact tracking; Graphiti is a temporal graph framework you operate yourself. Graphiti’s current package metadata and license specify Apache-2.0, which should not be extended to the managed Zep platform. The operational distinction matters: Graphiti’s reference MCP and REST servers lack authentication, authorization, and prompt-injection protection. Any caller can access any group_id without an added security layer. Production deployments therefore require you to supply tenant isolation and those protections, rather than treating the reference servers as a secured managed-service replacement.
Yes. Mem0 Platform’s current native graph contributes entity-connected retrieval boosts to a combined score alongside vector and BM25 signals. It is not merely a separate relations payload appended after vector ranking. The graph connects memories through shared entities rather than typed, labeled entity-to-entity predicates. Feature documentation says native graph retrieval is automatic on all plans, with interactive visualization reserved for Pro and Enterprise. However, the pricing page labels graph memory on Pro. That documentation disparity remains unresolved, so confirm plan entitlements rather than assuming graph retrieval is Pro-only.
Zep meters ingestion by Episode size: one credit covers up to 350 bytes, with another credit for each additional 350 bytes or fraction. Retrieval, storage, threads, users, and graph storage consume zero credits; webhook invocations cost one-eighth credit where available. Cognee Standard pricing is $1.00 per 1M tokens processed, plus $5 per additional workspace. The additional-workspace charge is monthly. These are different billing units, so neither rate establishes a cheaper option. Compare actual Episode payload sizes, processed-token volumes, workspace counts, and applicable webhook usage for your workload.
Letta MemFS is an alternative approach to persistent agent memory, not an equivalent temporal knowledge graph. It stores long-term memory in an agent-owned git repository, commits edits for history and conflict handling, and uses worktrees for concurrent memory subagents such as dreaming. That supports agent-controlled memory editing and revision history. It does not establish automatic valid-time and transaction-time fact invalidation like Zep’s documented model. Letta’s newer architecture centers MemFS and dreaming, with its TypeScript Agent SDK recommended while the V1 SDK is being deprecated. Choose according to the memory model required.
Choose LangMem when you want composable memory extraction, hot-path tools, background consolidation, and prompt optimization inside a workflow you operate. Its functional primitives work across storage systems, with native LangGraph storage integration. That makes it relevant for LangGraph-oriented applications that need control over memory processing rather than a managed temporal graph service. The toolkit is MIT-licensed, but persistence and operations remain separate responsibilities. InMemoryStore loses memories on restart; production requires AsyncPostgresStore or similar database-backed storage. Budget for storage, model calls, and deployment rather than assuming a bundled service.
Yes, Supermemory documents a self-hostable local server, but its server binary is proprietary, not open source. The free lite license permits up to 10,000 stored documents. Local embeddings and local-model endpoints are supported, while connectors and hosted MCP differ from the local offering. Pricing-page references to Scale or Enterprise self-hosting describe a separate offering boundary. Offline operation also requires configuration: telemetry can be disabled, release checks need a separate opt-out, and webpage ingestion sends URLs to Firecrawl. Check model endpoints, input handling, telemetry, and update settings before claiming fully local operation.



