Honcho Memory Review: 90.4% Holds Up in Our Re-Score, Plus Pros and Cons

Honcho Memory Review: 90.4% Holds Up in Our Re-Score, Plus Pros and Cons

Honcho memory, Plastic Labs' AGPL-3.0 memory layer for AI agents, claims 90.4% on LongMemEval S. Our testing on 28 October 2026 recounted its raw result files and got the same 452 of 500. On LoCoMo, with both sides answering the same 1,540 questions, Honcho's lead over plain Claude Haiku 4.5 is 6.3 points, not the published 14.3.

Good memory. Smaller lead. Real trade-offs.

Is Honcho Memory Worth Using? The Verdict in One Table

Use Honcho when your agent must model a person over months; skip it for document RAG, instant recall, or a closed-source fork.

Honcho is the only AGPL-3.0 option among the dedicated memory layers (Mem0, Letta and cognee are Apache-2.0, LangMem is MIT), and its cloud bills reasoning per query on top of ingestion.

Older reviews still quote $100 in free credits. The docs now say $5, plus $5 a month with a card.

How Does Honcho Memory Work?

Your app writes messages between peers, and a background worker turns them into conclusions you can query in plain language or pull as context.

A peer is any participant, user or agent. The v3 quickstart in the Honcho docs shows the whole flow (source on GitHub):

import os
from honcho import Honcho
honcho = Honcho(workspace_id="my-app-testing", api_key=os.environ["HONCHO_API_KEY"])
alice = honcho.peer("alice")
tutor = honcho.peer("tutor")
session = honcho.session("session-1")
session.add_messages([
    alice.message("Hey there — can you help me with my math homework?"),
    tutor.message("Absolutely. Send me your first problem!"),
])
answer = alice.chat("What learning styles does the user respond to best?")

peer.chat() answers plain-language questions. Hybrid BM25 + vector search finds messages and conclusions, which are Honcho's derived facts. session.context(summary=True, tokens=10_000) returns token-budgeted context for a prompt.

Reasoning is asynchronous. A new fact appears after the deriver runs, not on the next read; the README's representation endpoint is the low-latency path.

Does Honcho's 89.9% LoCoMo Score Hold Up? We Re-Scored the Raw Files

89.9% and 90.4% both reproduce from Plastic Labs' raw files; on LoCoMo, though, the like-for-like lead over Haiku alone is 6.3 points.

On 28 October 2026 we recounted three result files from honcho-benchmarks (run folder a1d689b, named after the Honcho commit tested). The published column is self-reported on honcho.dev/evals.

Testing shows where the gap goes. The published baseline includes 446 adversarial questions, where Haiku scored 46.2%, and Honcho's run had none. Plastic Labs' own Benchmarking Honcho post says "Haiku alone scores 83.9%", close to our 83.6%. The evals page simply compares two question sets.

On short histories, the reason to pick Honcho is fewer tokens, not higher accuracy. LoCoMo histories of 16K to 26K tokens fit any 200K window, and ConvoMem found full context reaches 70-82% under about 150 conversations.

LongMemEval S is different: at about 115K tokens per history, the +27.8 lead holds. One scope note. These runs used a December 2025 setup with a Haiku 4.5 dialectic, while v3.4.1 (2026-10-27) defaults to gpt-5.4-mini.

# files: github.com/plastic-labs/honcho-benchmarks, folder a1d689b
import json, statistics
def score(f, drop_adv=True):
    per_conv = []
    for c in json.load(open(f))["detailed_results"]:
        qs = [q for q in c["question_results"] if not (drop_adv and q["category_name"] == "adversarial")]
        per_conv.append(sum(q["passed"] for q in qs) / len(qs))
    return round(100 * statistics.mean(per_conv), 1)
print(score("locomo_results_20251215_175728.json"))                  # 89.9
print(score("locomo_baseline_results_20251215_184837.json"))         # 83.6, same 1,540 Qs
print(score("locomo_baseline_results_20251215_184837.json", False))  # 75.4, incl. adversarial

Why Do Developers Choose Honcho?

Honcho wins on user modeling: it keeps a running picture of who someone is, and that memory follows them across their agent tools.

Vectorize (maker of the rival Hindsight) wrote a March 2026 Hermes memory provider comparison that calls it a behavioral model of the user, "not just a fact store". Every reason has a catch.

Token savings are where the marketing runs ahead. The homepage advertises 60-90%, but the evals page lists 89% on LongMemEval S, 52% on LoCoMo and 16% on BEAM 100K. A builder quoted on the homepage reports 10-15%.

Who Uses Honcho, and Who Is It For?

542,206 Python SDK downloads in the month to 28 October 2026 say Honcho has real users, mostly agent builders around Hermes and coding agents.

caption: Adoption signals, retrieved 2026-10-28.
items:
  - value: 542206
    label: PyPI honcho-ai downloads, last month
    source: pypistats.org
  - value: 101791
    label: npm @honcho-ai/sdk downloads, Sep 27 to Oct 26
    source: api.npmjs.org
  - value: 7803
    label: GitHub stars, 954 forks
    source: GitHub API

The homepage labels its logo strip "Used by developers at". That means individual developers at these organisations, not company-wide contracts or case studies.

Nous Research's Hermes Agent ships Honcho as a memory plugin (hermes plugins install honcho), and the Hermes Honcho docs list five tools, from honcho_profile to honcho_conclude.

Popularity isn't consensus. A 138-answer Hermes poll on X (Oct 2026) put Markdown notes first (27), Hindsight second (25) and Honcho third (22).

• Good fit: companions, tutors and coaching agents
• Good fit: personal coding agents shared across Claude Code, Codex and Cursor
• Poor fit: document RAG, next-turn recall, closed-source forks

Honcho Pros and Cons: What Do You Trade for the Accuracy?

Honcho's accuracy is real; the price is lag, token overhead, a heavy self-host stack and the AGPL, so budget for all four.

Self-hosting needs Postgres with pgvector, a deriver worker and a tool-calling LLM (defaults: gpt-5.4-mini, text-embedding-3-small). The CLI starts the API, deriver, Postgres and Redis; Docker Compose works too.

# .env: set these before starting
DERIVER_FLUSH_ENABLED=true   # small batches otherwise wait (#494)
AUTH_USE_AUTH=true           # off by default
AUTH_JWT_SECRET=your-secret  # generate with scripts/generate_jwt_secret.py

uv tool install honcho-cli
honcho start --setup

Pros: where Honcho earns its place

• User modeling that developers describe as knowing who you are
• The strongest long-history result in our recount: +27.8 on LongMemEval S
• Open source, self-hostable, with plugins for Claude Code, Codex, Cursor, Hermes and more

Cons: what it costs you

• Lag. Developers report a 9.1 s minimal dialectic trace (#1101) and 2.16 s added to every Hermes API turn (#1289). The homepage's "~200 ms" is a vendor claim about context().
• Query cost. For 10,000 users adding 20K tokens a month, ingestion is $400, but 30 Low-tier queries each is $3,000 (Minimal: $300). The query tier, not ingestion, decides your Honcho bill.
• Self-host upkeep. GitHub users report memory missing until the deriver flushes (#494) and a hard-coded model fallback (#1180). Leaving the cloud means replaying messages, because embeddings aren't exported (#721).
• AGPL-3.0. One comparison article says self-hosting forces you to release your app's source. That overstates it: AGPL §13 applies when you modify Honcho and users reach it over a network. Mem0, Letta and cognee are Apache-2.0 and LangMem is MIT, so Honcho is the copyleft outlier among dedicated memory layers. Not legal advice.

Run the quickstart on the $5 credit with one real conversation log before you commit.

Frequently Asked Questions

Is Honcho memory free?

Partly. The cloud gives a $5 credit, plus $5 a month with a card, and startups under $5M raised can get $1,000 in credits. Self-hosting has no license fee under AGPL-3.0, but you pay your own LLM and embedding bills.

Can I use Honcho in a closed-source SaaS?

Yes, if your app calls an unmodified Honcho server through its API. If you modify Honcho and serve it over a network, AGPL §13 requires offering that modified Honcho source. Your own app stays closed. Not legal advice; ask counsel if you fork.

Honcho vs Mem0 or Hindsight: which should I pick?

Pick Mem0 (Apache-2.0) for the fastest start, Hindsight (MIT) to save tokens, and Honcho for user modeling. One developer reports Hindsight "used far fewer tokens" on Hermes (X, Oct 2026). Mem0's blog says Honcho lacks public benchmarks, yet it has published 21 raw result files since 2025-12-19. See the full ranking.

title: References
items:
  - title: Honcho Evals
    publisher: Plastic Labs
    year: 2025
    url: https://honcho.dev/evals
  - title: plastic-labs/honcho README
    publisher: GitHub
    year: 2026
    url: https://github.com/plastic-labs/honcho
  - title: plastic-labs/honcho-benchmarks
    publisher: GitHub
    year: 2025
    url: https://github.com/plastic-labs/honcho-benchmarks
  - title: Benchmarking Honcho
    publisher: Plastic Labs
    year: 2025
    url: https://plasticlabs.ai/blog/research/Benchmarking-Honcho
  - title: Honcho Memory
    publisher: Nous Research (Hermes Agent docs)
    year: 2026
    url: https://hermes-agent.nousresearch.com/docs/user-guide/features/honcho
  - title: GNU Affero General Public License v3
    publisher: Free Software Foundation
    year: 2007
    url: https://www.gnu.org/licenses/agpl-3.0.html
  - title: "LongMemEval: Benchmarking Chat Assistants on Long-Term Interactive Memory"
    publisher: arXiv
    year: 2024
    url: https://arxiv.org/abs/2410.10813
  - title: Evaluating Very Long-Term Conversational Memory of LLM Agents (LoCoMo)
    publisher: arXiv
    year: 2024
    url: https://arxiv.org/abs/2402.17753
  - title: ConvoMem
    publisher: arXiv
    year: 2025
    url: https://arxiv.org/abs/2511.10523