Cognee vs Honcho
Cognee turns text, files, and company data into a knowledge graph that your agent can search, one graph per dataset. It's Apache-2.0 and runs inside your Python process by default. Honcho reasons over conversations into a representation of each person and agent, and hands your agent that model in one call. Cognee remembers what your data says. Honcho remembers who your users are.
- Cognee
- An LLM extracts a knowledge graph from your data
- Honcho
- Reasons over messages into conclusions
- Cognee
- $1.00 per million tokens processed on Cloud
- Honcho
- $2.00 per million tokens ingested
- Cognee
- Apache-2.0 core
- Honcho
- AGPL-3.0
- Cognee
- Runs inside your Python process
- Honcho
- Same code as the hosted service
Cognee or Honcho: the short answer
How memory gets built
Each step restates the vendor's own docs, listed under Sources.
Cognee and Honcho, row by row
| Row | Cognee | Honcho |
|---|---|---|
| What it is | Cognee "The open-source AI memory platform for agents", by Topoteretes in Berlin | Honcho An open-source memory layer for the agents and apps you already run |
| How memory gets built | Cognee An LLM extracts a knowledge graph from your data remember() chunks your data, and an LLM extracts entities and relationships from each chunk into a knowledge graph, with embeddings. improve() later reviews facts that disagree and folds session lessons into the graph | Honcho Reasons over messages into conclusions Stores each message as sent. A background deriver reasons over new messages and writes conclusions about each participant; dreaming consolidates them later |
| Whose memory it keeps | Cognee Datasets, with user permissions Datasets. Each dataset gets its own graph and vector store, with user, role, and tenant permissions on top. Per-user preferences are off by default | Honcho Peers: users, agents, and groups Peers: any user, agent, or group, plus each peer's view of the others |
| What a query returns | Cognee An answer your LLM writes, by default recall() routes most queries to hybrid graph and vector search and returns an answer written by your LLM. Other search types return raw chunks or summaries | Honchocontext() in about 200ms, or chat()context() returns a representation, a summary, and recent messages inside a token budget you set, in about 200ms. chat() answers a plain-language question about a peer |
| What you pay for | Cognee $1.00 per million tokens processed on Cloud Open source: your own LLM and embedding keys; ingesting ordinary prose costs about 8 to 10 times its size in tokens. Cognee Cloud: $1.00 per million tokens processed and $5 a month per extra workspace, with a free tier. Enterprise is priced on request | Honcho $2.00 per million tokens ingested $2.00 per million tokens ingested. Reading context is unlimited. chat() queries cost $0.001 to $0.50 each, by reasoning level |
| Open source | Cognee Apache-2.0 core Core, Apache-2.0. The Enterprise runtime and the production Postgres graph adapter are proprietary | Honcho AGPL-3.0 Server and SDKs, AGPL-3.0 |
| Self-hosting | Cognee Runs inside your Python process pip install cognee runs in your Python process, with Ladybug, LanceDB, and SQLite files by default. Neo4j and other stores for production. Docker images for the API, UI, and MCP server | Honcho Same code as the hosted service honcho start --setup runs the API, Postgres, and Redis on Docker, plus an LLM key. The hosted service runs the same code |
| Works with | Cognee Plugins for Claude Code, Codex, Hermes Agent, and OpenClaw, a community extension for Pi, and an MCP server for Cursor and Cline. LangGraph, CrewAI, Google ADK, Haystack, n8n, and Dify. Connectors for Slack, Notion, Google Drive, GitHub, and Linear | Honcho Plugins for Claude Code, Codex, OpenCode, Hermes Agent, OpenClaw, Kilo Code, Pi, and DeepSeek Harness. A hosted MCP server for other clients. Guides for the Vercel AI SDK, LangGraph, CrewAI, and n8n |
| Published benchmarks | Cognee BEAM 100K 0.79 and BEAM 10M 0.67, 20 questions each. LoCoMo 91.3%. Self-reported, with answers, judge verdicts, and configs published | Honcho LongMemEval S 90.4, LoCoMo 89.9, BEAM 1M 61.8 and 10M 40.9. Self-reported, with configs and raw outputs on GitHub |
As of November 16, 2026. Benchmark scores are each vendor's own, from separate runs, and aren't directly comparable.
Cognee turns your data into a knowledge graph, one per dataset
Cognee 1.0 has four main calls: remember, recall, improve, and forget. remember() takes text or files and, without a session ID, runs the whole pipeline in one call: it stores the data in a dataset, chunks it, extracts entities and relationships with an LLM, embeds it, and builds the graph. Cognee's own docs put the cost at two LLM calls per chunk, one for a summary and one for extraction, which makes writes slower and more expensive than embedding-only memory (remember, Cognee). With a session ID, remember() writes to a fast session cache instead, and improve() moves that content into the graph in the background.
The model is yours to choose. The default is openai/gpt-5.6-luna on your own key, and Ollama, Anthropic, Gemini, Bedrock, and others work too (LLM providers). With no key, Cognee falls back to a local GLiNER extractor, which its README calls a demo (README). An optional RDF/OWL ontology can pin down the entity types the LLM extracts (ontologies).
Memory is scoped by dataset. In multi-user mode each dataset gets its own graph and vector store, and users, roles, and tenants get read, write, delete, and share rights on datasets; Cognee's docs say a tenant is not a database boundary (multi-tenancy). Per-user personalization is off by default. Turned on, it learns weights from a user's ratings and nudges ranking for that user and dataset (personalized memory).
recall() checks the query against five routing rules and otherwise uses HYBRID_COMPLETION, which searches the graph and vectors and has your LLM write the answer (recall). improve() reviews entity facts that disagree, using the documents and dates they came from, and marks which values are current, superseded, or still disputed (improve). Cognee Cloud charges $1.00 per million tokens processed and $5 a month for each workspace after the first (pricing).
Honcho reasons over every message into a model of each peer
Honcho stores each message as it was sent, labelled with the peer who said it. A peer is any participant: a person or an agent. A background process called the deriver reasons over new messages and writes conclusions about each peer, including things that follow from what was said but were never stated outright. When a user corrects a fact, the deriver writes a new conclusion with a timestamp, and the old one stays for now. Dreaming runs later, once enough new conclusions have built up, deletes conclusions a newer fact has replaced, and merges ones that say the same thing.
Your agent reads memory two ways. session.context() returns the representation, a summary, and recent messages inside a token budget, in about 200 milliseconds, and those reads are unlimited. peer.chat() takes a question and reasons over the representation to answer it, at one of five levels from minimal to max, priced per query from $0.001 to $0.50.
Writes are asynchronous. A conclusion lands after the deriver runs, in time for the next turn but not the same one. Each peer can also keep its own view of every other peer it has observed. A support agent's model of a customer and the customer's model of that agent are separate objects.
Pick Cognee to build agent memory from documents and company data
Cognee is built to turn a body of data into a graph your agent can query. It takes files and code repos, has connectors for Slack, Notion, Google Drive, GitHub, and Linear, and can follow an ontology you supply. If your agent's job is to answer from what your company has written down, that's the shape you want. Honcho is built around messages between peers and reasons about the people in them, not about a document corpus.
Cognee also runs as a library. pip install cognee gives you working memory in your Python process with local file stores and no server, and the Apache-2.0 core clears policies that rule out Honcho's AGPL-3.0. Self-hosting Honcho means running its API with Postgres and Redis. Honcho's writes also land after a background step, in time for the next turn but not the same one.
Honcho models every user and agent by default, and serves that model in about 200ms
Honcho reasons over each conversation into a representation of every peer, and context() returns it in about 200ms, as often as your agent asks, without metering the reads. Start on Honcho Cloud with credits, or self-host the same server.
FAQ
01Can I use Cognee and Honcho together?+
Yes. They answer different questions. Cognee can hold the graph of your documents and company data, and Honcho the model of each user your agent talks to. Your agent reads both, so watch how much each one adds to the context window.
02Which one costs less?+
Self-hosted Cognee is free software, and you pay your LLM and embedding provider: Cognee's docs estimate ingestion at about 8 to 10 times the corpus size in tokens, and its default recall() makes an LLM call per query (token efficiency). Cognee Cloud charges $1.00 per million tokens processed plus $5 a month per extra workspace (pricing). Honcho Cloud charges $2.00 per million tokens ingested, reasons on its own models, and doesn't meter context reads; chat() queries cost $0.001 to $0.50 each (pricing). Which costs less depends on how much you ingest and how often your agent reads.
03Does Cognee keep a model of each user?+
Not by default. Cognee scopes memory by dataset, with user permissions on each one. Its personalization feature is off by default; turned on, it learns from 1-to-5 ratings and adjusts ranking for that user (personalized memory). Honcho builds a representation of every peer, user or agent, from their messages without extra setup.
04Do they work with Claude Code and Hermes?+
Both do. Cognee has plugins for Claude Code, Codex, Hermes Agent, and OpenClaw, a community extension for Pi, and an MCP server for other clients (integrations). Honcho has plugins for Claude Code, Codex, OpenCode, Hermes Agent, OpenClaw, Kilo Code, and Pi, plus a hosted MCP server.
05Can I use either one commercially?+
Yes. Cognee's core is Apache-2.0, so you can modify it and keep changes private; its Enterprise runtime is a separate proprietary product. Honcho is AGPL-3.0: you can modify it and run it as a service, and if you do, you publish your changes. Honcho Cloud has no such requirement.
- [01]topoteretes/cognee README
- [02]Cognee license (Apache-2.0)
- [03]Cognee docs: remember
- [04]Cognee docs: recall
- [05]Cognee docs: improve
- [06]Cognee docs: data isolation and multi-tenancy
- [07]Cognee docs: personalized memory
- [08]Cognee docs: LLM providers
- [09]Cognee docs: graph stores
- [10]Cognee docs: token efficiency
- [11]Cognee docs: accuracy benchmarks
- [12]Cognee docs: integrations
- [13]Cognee pricing
- [14]Cognee: AI memory tools vs databases
- [15]Honcho pricing
- [16]honcho.dev/evals
- [17]plastic-labs/honcho
- [18]Honcho docs: representation
- [19]Honcho docs: dreaming