Honcho asks an LLM what your user is like. Dakera remembers what happened.

Honcho, from Plastic Labs, stores conclusions that reasoning models draw about each person your agent talks to, and answers questions about them with another LLM call. Dakera stores the source memories with provenance, importance, decay and a knowledge graph, ranks them deterministically in milliseconds, and leaves the reasoning to your own model at answer time. One is interpretation, the other is evidence.

Reviewed October 2026

How Honcho works

Honcho calls itself persistent, reasoning-based memory for users and other peers. Its data model has four primitives: workspaces contain peers (entities that persist over time, such as a user or an agent) and sessions (interaction threads), and messages are the data units that trigger reasoning. Work then happens at three different moments.

• On write. Per the architecture docs, a message is stored and a reasoning task is enqueued in the same request, and the API returns immediately. Reasoning runs afterwards in a queue consumed by the deriver worker, with session-level ordering.
• In the background. The deriver extracts explicit and deductive conclusions from messages. A summarizer rolls up session summaries. The dreamer runs later, once at least 50 new conclusions exist and 8 hours have passed, and uses deduction and induction agents to consolidate conclusions and write the peer card, a profile of stable facts capped at 40 per card.
• Representations. A peer representation is the evolving, reasoned model of a peer: conclusions (deductive, inductive, abductive), summaries and the peer card. With observe_others, one peer can hold its own view of another based only on interactions it shared.
• On query. peer.chat(), the dialectic API, runs the agent's full reasoning loop with an LLM and returns a synthesised answer. session.context() is a read without an LLM call.

The result is a rich, evolving profile of a person, with an LLM in three places: background derivation, dreaming and the query itself. The README lists LLM provider API keys as a requirement.

What Dakera does instead

Dakera keeps the evidence. A store embeds the text and extracts entities on-device, and a recall runs HNSW and BM25, fuses them with RRF and reranks with a cross-encoder, all in one container with the models included. Nothing is rewritten, so each result is a memory you stored, with its importance, timestamps and session. Your own model reasons over that evidence when it answers.

Cost and latency of one question

An interpretation layer pays at query time. A retrieval layer pays at the index.

The same question in code

Both snippets store a preference and ask what the user prefers. The Honcho side is from its quickstart and the Dakera side uses the Python SDK.

from honcho import Honcho

honcho = Honcho(
    workspace_id="my-app",
    api_key=os.environ["HONCHO_API_KEY"],
)
alice = honcho.peer("alice")
session = honcho.session("session-1")
session.add_messages([
    alice.message(
        "I prefer email to phone calls"),
])

# an LLM reasons over stored conclusions
answer = alice.chat(
    "what does the user prefer?")

# returns a model-written answer (str):
# "Based on conclusions, the user
#  prefers ..."

from dakera import DakeraClient

client = DakeraClient(
    "http://localhost:3000", api_key=KEY)

client.store_memory(
    agent_id="alice",
    content="I prefer email to phone calls",
    importance=0.8,
)

# hybrid retrieval + rerank, on-device
response = client.recall(
    agent_id="alice",
    query="what does the user prefer?",
    top_k=5,
)
for m in response.memories:
    print(round(m.score, 2), m.content)

# returns ranked source memories with
# scores, plus a rerank_report

What you can audit

Honcho keeps the original messages and can return the conclusions and messages it consulted, so both systems retain source text. They differ in what sits between the source and the answer.

Where Honcho is strong, and using both

If you are building something that has to understand people, such as a tutor, companion or assistant that notices patterns over months, Honcho is designed for exactly that: formal-logic conclusions, peer cards and per-peer perspectives are things a store of memories does not produce on its own. It is AGPL-3.0 open source with a managed service.

The two also sit at different layers. Dakera can be the evidence store, holding exactly what happened with ranked, explainable recall, while your LLM, or Honcho, interprets it. This is an architecture pattern, not a tested integration.

Prefer managed? Dakera Cloud is coming. Join the waitlist.

On benchmarks, Dakera reports LoCoMo Recall@20 of 88.2% (does retrieval surface the answer) while Honcho reports QA accuracy (does an LLM answer correctly). Different measurements. Method

Frequently asked questions

Related comparisons: vs Letta · vs Cognee · vs Hindsight · vs Supermemory