Cognee Alternatives: 7 Agent Memory Tools Compared

Cognee alternatives are other memory systems for AI agents: Mem0, Graphiti, Zep, Letta, Hindsight, MemPalace and Supermemory. People look for one when Cognee’s knowledge-graph pipeline is more than they need for simple per-user memory, when they want temporal fact tracking in open source, or when they want the agent itself to manage memory. For that second reason, Graphiti and Hindsight both fit; Graphiti needs a graph database, while Hindsight runs its graph and temporal recall on Postgres, all in the MIT release.

Below: what Cognee does, a comparison table, a short section per alternative, and how to choose. Facts come from each project’s README, docs and pricing page, checked in October 2026.

What Cognee does, and why people look for Cognee alternatives

Cognee is an open-source (Apache 2.0) memory engine that turns documents, code and conversations into a knowledge graph plus vector index that agents can search. Text becomes entities, relationships and chunks; code becomes a graph of symbols and dependencies. You use it through four operations: remember, recall, improve and forget.

From the Cognee README:

• It stores data in three layers: relational (documents and provenance), vector (embeddings) and graph (entities and relationships).
• Since v1.6 (September 2026) it can extract a graph with the local GLiNER model and embed with a local model, so it runs without an LLM key. Add a key to get generated answers.
• It ships plugins for Claude Code, Codex and OpenClaw, an MCP server, and SDKs for Python, TypeScript and Rust.
• The research behind it is Markovic et al., 2025, on optimizing the interface between knowledge graphs and LLMs.

Cognee is a good fit for a “company brain” over docs, tickets and code. The common reasons people compare it with others:

1. The job is per-user chat memory. A graph pipeline is more machinery than storing “Dana prefers short answers.”
2. Some production pieces are licensed. The README calls Postgres-as-graph-store “a demo feature,” with the production version “available as a licensed product,” and says the bundled GLiNER extractor is a demo of the small-model pipeline.
3. Temporal memory is an Enterprise item. Cognee’s pricing page lists “bi-temporal memory & conflict resolution” under Enterprise (checked 2 November 2026). The open-source release now covers part of this: since v1.6.6 (29 October 2026), improve() reviews conflicting facts by default when an LLM is set (keyless installs skip it), and a new API lets a user pick the accepted fact. See the table below.
4. They want an agent runtime, not a memory layer.

Conflict handling in open-source Cognee 1.6.6

From the v1.6.6 release notes and the pull requests behind them (#6401, #6416):

In this design a person picks the winner: Cognee flags the conflict, and a person or your code decides. Graphiti and Hindsight take a different route. Graphiti records when each fact became valid and invalid, so a newer fact supersedes an older one on its own. Hindsight consolidates memories into evidence-backed observations and recalls by time as well as meaning, all in its MIT release.

For background on graph-based memory in general, see knowledge graphs for AI memory.

Cognee alternatives at a glance

Prices are published list prices and change often.

Mem0

Mem0 is a memory layer focused on personalization. It extracts facts from conversations with one LLM call per add, stores them for user, session and agent scopes, and retrieves them with semantic, BM25 and entity matching fused together. It runs as a library, a self-hosted server, or the managed Platform.

Note the graph difference. Mem0’s v3 migration guide says graph memory “is removed from the open-source SDK” and now lives on the hosted Platform, on Custom plans only.

• Pick Mem0 for simple user memory with a small API and many framework integrations.
• Look elsewhere if you need an open-source knowledge graph over documents. That’s Cognee’s ground.

The head-to-head is in Mem0 vs Cognee, and the wider field in our Mem0 alternatives comparison.

Graphiti

Graphiti is Zep’s open-source framework for temporal context graphs. Entities are nodes, facts are edges with validity windows, and every fact traces back to the raw “episode” it came from. When a fact changes, the old one is invalidated, not deleted. Retrieval combines embeddings, BM25 and graph traversal.

Compared with Cognee, Graphiti is narrower and more time-focused. It’s a library: you bring the graph database and build users, threads and tooling yourself. It defaults to OpenAI for extraction and embeddings.

• Pick Graphiti if fact history (“what was true before?”) matters more than document ingestion.
• Look elsewhere if you don’t want to run a graph database.

Zep

Zep is the managed service on top of Graphiti’s ideas. It builds a context graph per user, customer or account, adds users, threads and a dashboard, and claims sub-200 ms retrieval. Zep stopped maintaining its open-source Community Edition in April 2025, so self-hosting now means an Enterprise BYOC deal. Pricing is credit-based on ingestion: 1 credit per 350 bytes sent, with retrieval unmetered.

• Pick Zep if you want temporal graph memory as a managed service with SLAs.
• Look elsewhere if open source is the reason you chose Cognee.

Our Zep alternatives guide covers this in more detail.

Letta

Letta (formerly MemGPT) is the agent runtime, not a memory store you call. Letta Code agents keep memory as Markdown files in a git-backed filesystem (MemFS), search their message history, and run background “dreaming” to consolidate lessons. It’s Apache 2.0.

• Pick Letta if you’re building a long-lived agent and want it to own and rewrite its memory.
• Look elsewhere if you need a memory backend for an existing agent. Letta’s Agent SDK is TypeScript only and its Python client is deprecated.

See the Letta guide for the full picture, or Letta vs LangChain memory if you’re weighing it against LangChain.

Hindsight

Hindsight is an MIT-licensed memory server. retain uses an LLM to extract facts, entities, relationships and time data. recall runs semantic, BM25, graph and time-range searches in parallel, then merges them with rank fusion and a cross-encoder reranker. reflect reasons over memories to answer open questions.

In the background it consolidates facts into observations, beliefs that keep their supporting quotes and get refined when new evidence arrives. Mental models are standing answers (“What are this user’s preferences?”) that Hindsight keeps up to date. It runs on PostgreSQL with pgvector, so entity links live there rather than in a separate graph database.

Two points matter for Cognee users. First, what Cognee licenses or reserves for Enterprise, a production Postgres graph and temporal memory, is in Hindsight’s open-source server, along with consolidation, reflect and mental models. Second, it has published long-history results: on BEAM it scores 73.9 at 1M tokens and 64.1 at 10M, versus Mem0’s 64.1 and 48.6, per Mem0’s own comparison (vendor-run). It also ships native plugins for Claude Code, Codex, Cursor and Copilot, plus an MCP server per bank.

• Pick Hindsight if your memory is mostly what an agent learns from interactions over time, histories run long, or you want graph and temporal memory self-hosted under MIT.
• Look elsewhere if you need a graph over a large document and code corpus; Cognee is built for that. It has no Drive or Notion-style document connectors, every retain makes LLM calls, and the README says Hindsight “may be overkill” for simple workflow automations.

MemPalace

MemPalace is the opposite end of the design range from Cognee. Cognee runs a pipeline that turns your material into entities, relationships and chunks. MemPalace keeps the material: its README says it “does not summarize, extract, or paraphrase.” Conversations and files are stored verbatim, sorted into wings, rooms and drawers, and searched locally over ChromaDB. It is MIT, Python, runs on your machine, and needs no LLM and no API key for the store or the search. It ships 45 MCP tools and auto-save hooks for Claude Code, Codex CLI and Cursor.

That makes it the thing to look at for reason 1 above, when a graph pipeline is more machinery than the job needs. Read its benchmark claim carefully: the headline 96.6% on LongMemEval is retrieval recall@5, whether the right session appears in the top five results, which is not the end-to-end answer accuracy other systems report. Keeping everything also means the store grows with everything you feed it, and nothing resolves a fact that changed, which is the exact thing Graphiti and Zep are built for.

• Pick MemPalace if you want a local, private archive of your own work that an agent can search, with no write-time LLM bill.
• Look elsewhere if you need structure over the raw text: a graph, facts with validity windows, or consolidated beliefs.

See MemPalace explained and Mem0 vs MemPalace.

Supermemory

Supermemory is a hosted memory and context API. It extracts facts, keeps user profiles, combines RAG over your files with personal memory in one query, and syncs from Google Drive, Gmail, Notion, OneDrive and GitHub. Its README lists multi-modal extractors for PDFs, images, video and code.

• Pick Supermemory if you want document RAG and user memory from one managed API, with little to run.
• Look elsewhere if fully self-run, open infrastructure is a requirement. A local server exists, but self-hosting is listed under the $399/month Scale plan.

How to choose a Cognee alternative

Match the tool to what your memory is made of.

Three checks before you switch:

1. Do you need a graph database? Graphiti does. Cognee ships local defaults and can swap in production backends. Hindsight and Mem0’s server run on Postgres.
2. Who calls the LLM, and how often? Mem0, Graphiti and Hindsight extract with an LLM on every write. Cognee can use a local model, and MemPalace calls no model at all.
3. Can you move data later? Cognee documents imports from Mem0, Letta, Zep and Graphiti. Check the export path of whatever you pick, too.