Honcho vs Mem0 2026: Memory Model, Setup, MCP, Pricing

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.

HonchoMem0Hindsight
Maker and repositoryPlastic Labs, plastic-labs/honchoMem0, mem0ai/mem0Vectorize, vectorize-io/hindsight
LicenseAGPL-3.0, with a network clause (section 13)Apache 2.0MIT
What it storesPeers, sessions and messages, with representations and conclusions about each peerMemories extracted by an LLMWorld facts and experience facts, then observations
Default storagePostgres with pgvectorLocal Qdrant and SQLite historyPostgres
When memory updatesA background queue updates peer representationsLLM extraction when you call addretain returns at once, consolidation runs in the background
How you read memorySearch, or chat with five reasoning levelsSearchrecall and reflect
Hosted MCP serverhttps://mcp.honcho.dev, Streamable HTTPhttps://mcp.mem0.ai/mcp, 11 toolsHindsight MCP server
Hosted price$2.00 per 1M tokens stored, free reads, $0.001 to $0.50 per reasoning queryFree tier at $0 with limits, Custom tier with no public priceHindsight 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.

Diagram of Honcho vs Mem0 memory paths: Mem0 extracts memories with an LLM into a vector store and returns them by search, Honcho updates peer representations in a background queue and answers through search or a reasoning chat, and Hindsight retains facts, consolidates observations and reflects on them before the next action

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:

  1. Python, with uv to manage the environment.
  2. PostgreSQL with the pgvector extension, local or managed. Redis is optional.
  3. 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:

  1. Decide whether you need search over facts or a reasoning query about a user before you pick.
  2. Get your legal team's sign-off on AGPL-3.0 before Honcho goes into any deployment, internal tools included.
  3. 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.