Honcho vs Mem0 2026: Memory Model, Setup, MCP, Pricing
Say you ask Mem0 and Honcho the same question: "What does Ana prefer?" Mem0 searches the memories it extracted when you called add. Honcho sends the question to a reasoning model over the picture of Ana it built in the background. Its hosted service bills that query from $0.001 to $0.50, by reasoning level.
That is the core of Honcho vs Mem0. Both products answer "what does the agent know about this user." They answer it in two ways, and the difference sets cost, setup and what your agent can do with the answer.
Here's the short answer. Mem0 is an Apache 2.0 library with a hosted Platform. It extracts memories with an LLM and finds them by search. Honcho is an AGPL-3.0 library and hosted service from Plastic Labs. It models each user as a peer, updates that model in a background queue, and answers questions about the peer through a chat endpoint. I think memory is not search. Hindsight also keeps what the agent did and whether it worked.
I build Hindsight. Every fact about Honcho and Mem0 below comes from their own docs, repository or pricing page, read in November 2026. For the wider field, read agent memory systems compared. For the basics, start with AI agent memory.
Want to see retain, recall and reflect run on your own data? Run the Hindsight quickstart and you'll have a local server in a few minutes.
Honcho vs Mem0 at a Glance
Honcho is a memory library and hosted service for stateful agents. Mem0 is a library plus a hosted API. I put Hindsight in the third column, so you can see what a third design looks like. Facts below are as of November 2026.
| Honcho | Mem0 | Hindsight | |
|---|---|---|---|
| Maker and repository | Plastic Labs, plastic-labs/honcho | Mem0, mem0ai/mem0 | Vectorize, vectorize-io/hindsight |
| License | AGPL-3.0, with a network clause (section 13) | Apache 2.0 | MIT |
| What it stores | Peers, sessions and messages, with representations and conclusions about each peer | Memories extracted by an LLM | World facts and experience facts, then observations |
| Default storage | Postgres with pgvector | Local Qdrant and SQLite history | Postgres |
| When memory updates | A background queue updates peer representations | LLM extraction when you call add | retain returns at once, consolidation runs in the background |
| How you read memory | Search, or chat with five reasoning levels | Search | recall and reflect |
| Hosted MCP server | https://mcp.honcho.dev, Streamable HTTP | https://mcp.mem0.ai/mcp, 11 tools | Hindsight MCP server |
| Hosted price | $2.00 per 1M tokens stored, free reads, $0.001 to $0.50 per reasoning query | Free tier at $0 with limits, Custom tier with no public price | Hindsight Cloud, Hindsight Enterprise |
Two rows matter most. The first is what each product stores. Mem0 keeps extracted memories. Honcho keeps a model of each peer. The second is how each one answers. Mem0 searches. Honcho can search too, and it can also reason over the model when you ask a question, at a price per level.
How Mem0 Stores and Retrieves Memory
Mem0 Open Source runs two ways: as a library in your app, or as a self-hosted Docker server. Mem0 Platform is a hosted API with a dashboard, and it needs a Platform API key.
The library defaults are a local Qdrant vector store at /tmp/qdrant, an OpenAI LLM, OpenAI text-embedding-3-small embeddings, and a SQLite history file at ~/.mem0/history.db. The reranker is off until you configure one.
The Mem0 Python quickstart shows the loop:
from mem0 import Memory
m = Memory()
messages = [
{"role": "user", "content": "Hi, I'm Alex. I love basketball and gaming."},
{"role": "assistant", "content": "Hey Alex! I'll remember your interests."}
]
m.add(messages, user_id="alex")
results = m.search("What do you know about me?", filters={"user_id": "alex"})
print(results)
Each add call hands the messages to the LLM, which extracts the memories to store. search returns the stored memory with a score. That's the whole read path: a query goes in, ranked memories come out.
Graph memory is listed on the Custom tier of the pricing page. Mem0 ships Python and TypeScript packages, mem0ai on pip and npm.
I cover more of Mem0's neighbours in Mem0 alternatives. For a library built on LangGraph, see LangMem vs Mem0.
How Honcho Stores and Reasons Over Memory
Start simple. Honcho organises everything around peers. The Honcho README says humans and AI agents are both modeled as peers. A workspace holds peers, peers join sessions, and sessions hold messages.
Storing a message is synchronous through the API. The insight work is not. The README says insights are asynchronous, through a background queue that the deriver worker process consumes. The deriver generates representations, summaries and peer cards, and it manages dreaming tasks. The homepage names that background reasoning "Dreaming."
The README defines two of the derived records. Conclusions are what Honcho has extracted about a peer. Peer cards are compact identity summaries. Honcho stores these records as vector-embedded documents, keyed by an observer peer and an observed peer. So a peer is more than a message log. It has a short identity card, a set of extracted conclusions and a representation, all built after the message arrives. Say Ana sends one message. The API stores it at once. Later, the deriver turns it into conclusions and updates her representation. A chat question about Ana then reads those derived records and not the raw message log.
You read memory in two ways. Search is hybrid, BM25 plus vector, through peer.search, session.search and honcho.search. Or you call the chat endpoint, POST /v3/workspaces/{workspace_id}/peers/{peer_id}/chat. Its reasoning_level is optional, defaults to low, and accepts minimal, low, medium, high and max. The chat docs say the level controls the model, the tools, the thinking budget and the output limits of the request.
The two read paths differ in one way. Mem0 returns stored memories by search. Honcho's chat endpoint answers a question about one peer at five reasoning levels.
Read the diagram left to right. The two grey lanes end at search or chat. The blue lane ends at the next action. That gap is why I wrote this page.
Honcho vs Mem0 Setup: Self-Hosting, MCP, Claude Code and Hermes Agent
Self-hosting
Honcho needs three things, from its README:
- Python, with
uvto manage the environment. - PostgreSQL with the pgvector extension, local or managed. Redis is optional.
- An API key for one LLM provider, set as
LLM_OPENAI_API_KEY.
Then run the Docker path:
git clone https://github.com/plastic-labs/honcho.git
cd honcho
cp docker-compose.yml.example docker-compose.yml
cp .env.template .env # set LLM_OPENAI_API_KEY
docker compose up
The manual path runs uv sync, then uv run alembic upgrade head, then uv run fastapi dev src/main.py. It also needs the deriver, which you start in a second terminal.
Mem0 open source needs pip install mem0ai, an OPENAI_API_KEY for the defaults (or another configured LLM and embedder), and a Memory() object. The snippet above is the whole setup.
Picture Marco, who self-hosts Honcho by the manual path. He runs the migration and starts the API with uv run fastapi dev src/main.py. Messages go in and come back. Nothing about the peers gets derived. He missed the second terminal. The README says the deriver is a separate process that builds the representations. Honcho's self-host is two processes plus Postgres with pgvector and an LLM key.
Claude Code
Honcho's MCP guide gives this line for Claude Code, with the key from your Honcho account. The docs also list a Claude Code plugin, added with /plugin marketplace add plastic-labs/claude-honcho.
claude mcp add honcho \
--transport http \
"https://mcp.honcho.dev" \
--header "Authorization: Bearer hch-your-key-here" \
--header "X-Honcho-Plugin: claude-code"
Mem0's MCP docs give this line, and it needs a Mem0 account for sign-in:
npx mcp-add \
--name mem0-mcp \
--type http \
--url "https://mcp.mem0.ai/mcp" \
--clients "claude code"
For Hindsight, one command wires Claude Code to a memory bank. The Coding Agents page documents it:
npx @vectorize-io/hindsight-coding-agents install claude-code
More on the Claude Code side is in Claude Code memory.
Hermes Agent
Honcho installs in Hermes with hermes plugins install honcho, then hermes memory setup, from the Hermes docs. The README and the Hermes page word the install differently, so follow the Hermes page. For the field, see Hermes Agent memory providers.
Known issues
Check each tracker before you commit. Honcho has issue #1615, "[Hermes] Plugin fails to load on current Hermes main: two internal imports were removed," opened 2026-11-18. Mem0 has issue #7475, where the Claude Code plugin's MCP server ignores the user_id option, so searches use the OS account name.
View Hindsight on GitHub. One npx command gives Claude Code, Codex and other coding agents one shared memory bank per repository.
Honcho vs Mem0 License and Pricing
What AGPL-3.0 means for a company that runs Honcho
The license is the row of the table that a legal team reads first. Mem0 is Apache 2.0 and Hindsight is MIT, and neither has a network clause. Honcho is AGPL-3.0, and that clause reaches inside your company.
Start with what it says. Section 13 of Honcho's LICENSE file reads: "if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network ... an opportunity to receive the Corresponding Source of your version". In plain words: change Honcho, and every user of that changed copy over the network can ask for its source.
Internal deployments count. The clause says "all users." It does not say "customers" or "the public." Staff who reach an internal Honcho server are users of it. The FSF's GPL FAQ says a program "expressly designed to accept user requests and send responses over a network" meets the criteria, and Honcho is a server with a REST API. So a bug fix, a new endpoint or a custom deriver can put an internal deployment under section 13, and your legal team decides whether it does.
Then comes the gray area: how far the duty reaches. Is the agent code that calls Honcho part of the same program? The FAQ's "MereAggregation" entry says: "Where's the line between two separate programs, and one program with two parts? This is a legal question, which ultimately judges will decide." It names two tests, the mechanism of communication and the semantics of what is exchanged. The author of the license leaves the answer to judges, so you can't read a firm answer in the license text.
Google bans AGPL code. Google's published AGPL policy says: "Code licensed under the GNU Affero General Public License (AGPL) MUST NOT be used at Google." It adds: "The risks heavily outweigh the benefits."
Get a written sign-off from your legal team before Honcho goes into any deployment, internal tools included. Mem0's Apache 2.0 and Hindsight's MIT carry no network clause.
Pricing
Honcho's hosted prices, as of November 2026, from honcho.dev:
- Ingestion: $2.00 per 1M tokens stored.
- Reads: free and unlimited. Dreaming is included.
- Reasoning, per query: minimal $0.001, low $0.01, medium $0.05, high $0.10, max $0.50.
- Free credit: $5 for each new account, and $5 more each month after you add a card.
Mem0's prices, as of November 2026, from its pricing page:
- Free, $0: for the first 30 days, 10,000 adds and 1,000 retrievals a month. With your own LLM key after that, 50,000 adds and 10,000 retrievals a month.
- Custom, no public price: limits set to your volume. It adds graph memory, user profiles, Dream (memory consolidation), analytics, SSO, audit logs and on-prem deployment.
- Usage is billed past the limits, with a monthly cap you set.
The two price models differ in what they count. Honcho bills what you store and each reasoning query. Mem0 bills adds and retrievals past a free allowance. For another Mem0 price comparison, see Mem0 vs Supermemory.
Hindsight is MIT open source on Postgres. Hindsight Cloud is the managed service. Hindsight Enterprise runs in a private cloud, BYOC or on premises.
What the Honcho and Mem0 Benchmark Numbers Measure
Each vendor publishes a page that puts its own product first. The figures come from different setups, so I don't rank them against each other.
Honcho states 90.4% on LongMem S and 89.9% on LoCoMo on its evals page. The page says the runs use gemini-2.5-flash-lite as deriver and claude-haiku-4.5 as dreamer and dialectic. The LoCoMo figure uses an LLM judge that the page does not name.
Mem0 states 92.5 on LoCoMo on its research page. The page body shows no LongMemEval value. It names no judge model and no answer model.
Hindsight scores 94.6% on LongMemEval-S, as of November 2026. That is Hindsight v0.4.19 on the Agent Memory Benchmark, in single-query mode, scored as answer accuracy by an LLM judge. The paper, arXiv 2512.12818, names its judge, GPT-OSS-120b, and reports 91.4% with Gemini-3 on LongMemEval-S. Current results sit on the Hindsight benchmarks page.
Mem0's three-way comparison post on Mem0, Hindsight and Supermemory says Hindsight is "not publicly benchmarked." Hindsight published the paper and the Agent Memory Benchmark result.
My rule: compare one number with another only when the metric and the judge match. When a page won't name them, treat the number as a claim.
Honcho, Mem0 or Hindsight: How to Choose
Honcho fits a developer who wants a per-user model of each peer, with a Hermes Agent or Claude Code plugin, and whose legal team has signed off on AGPL-3.0.
Mem0 fits a developer who wants a hosted memory API and an MCP endpoint over HTTPS, with a library they can also self-host.
Hindsight fits an agent that must learn from what worked and what failed, in any framework or coding agent, on Postgres or Hindsight Cloud, under the MIT license.
Picture Tomás, whose Claude Code agent works in one repository every day. On Tuesday a migration fails on a missing index, and he fixes it by hand. With the Hindsight Coding Agents plugin, the session transcript goes to the repository's memory bank when the session stops. On Wednesday the first prompt of the new session gets a reflect answer from that bank. The agent checks the index before it runs the migration. Memory that learns changes the next action, not only the next answer about the user.
The retain docs classify each fact as "experience" or "world," and say your retain() call returns immediately while consolidation runs in the background. This is the quickstart code:
from hindsight_client import Hindsight
client = Hindsight(base_url="http://localhost:8888")
client.retain(bank_id="my-bank", content="Alice works at Google as a software engineer")
client.recall(bank_id="my-bank", query="What does Alice do?")
client.reflect(bank_id="my-bank", query="Tell me about Alice")
For the full contrast with one of the two, read Hindsight vs Mem0.
Frequently Asked Questions
Who makes Honcho, and which SDKs does it ship?
Plastic Labs publishes Honcho, in the repository plastic-labs/honcho. It ships a Python SDK, honcho-ai on PyPI, a TypeScript SDK, @honcho-ai/sdk on npm, and a command line tool, honcho-cli, on PyPI. The self-hosted server in that repository is the one the Docker lines above start.
Can I move from Mem0 to Honcho?
Honcho publishes a migration guide from Mem0. It includes a map of Mem0 calls to Honcho calls. The guide sits under the docs/v2 path, while the current Honcho docs are v3, so check that the steps still match the v3 API before you start a migration.
Is Honcho open source?
Yes. Honcho is open source under AGPL-3.0, a copyleft license, and the code is in plastic-labs/honcho. Open source does not mean free of duties: a changed copy owes its source to its network users, as the license section above sets out. Mem0 uses Apache 2.0 and Hindsight uses MIT, two permissive licenses.
Which Mem0 features need the hosted Platform?
Mem0's docs index tags entity filters v2, custom categories, webhooks and advanced retrieval as Platform-only. The pricing page lists graph memory, user profiles and Dream on the Custom tier. The open source library runs on your own infrastructure, with your own LLM and vector store.
Do Honcho and Mem0 use the same models by default?
Both default to OpenAI text-embedding-3-small for embeddings. Honcho's default LLM is gpt-5.4-mini, and Mem0's open source default LLM is gpt-5-mini. In both products you override the default in configuration. Check the defaults in each project's docs before you deploy, because a default model changes the cost of every add and every reasoning query.
Conclusion
Honcho vs Mem0 comes down to what each stores and how each answers. Mem0 searches extracted memories. Honcho reasons over a model of each peer. Hindsight adds the part after that: what your agent did and whether it worked.
Here's what to do:
- Decide whether you need search over facts or a reasoning query about a user before you pick.
- Get your legal team's sign-off on AGPL-3.0 before Honcho goes into any deployment, internal tools included.
- Pick a memory system by what it does after the agent fails, not only by what it knows about the user.
Then run the Hindsight quickstart, retain one real session, and call reflect. The open source version is MIT and runs on Postgres, so you can start local and move to Cloud later. When you want the managed route, create a Hindsight Cloud account and point your agent at it today.