Hermes Agent's Honcho memory: Dialectic user modelling.

Briefing

Ask most people how an AI assistant "remembers" you and they'll picture a list of facts in a database: your name, your job, your preferences, looked up when needed. Useful, but shallow. It tells the assistant *what* you said, never *how sure* it should be, or what to do when last week's note clashes with today's.

A memory project called Honcho, built by Plastic Labs, takes a different swing. Instead of filing facts away, it tries to build a working model of the person it's talking to and to update that model when the evidence shifts. It's an optional, opt-in memory backend you can plug into Hermes Agent, the open-source agent from Nous Research that drew a lot of attention after it was released. (Hermes was reported at around 22,000 GitHub stars in its first month; that figure climbed fast afterwards, so treat the number as an early snapshot rather than where it stands now.)

The interesting part for a business reader isn't the star count. It's the idea: a memory layer that holds beliefs about a user the way a thoughtful colleague would, with confidence levels and a sense of when something doesn't add up. The piece below walks through how that works, and where the marketing runs ahead of the documentation.

A quick caveat up front: some of the examples used here to explain Honcho's approach (the "tension record" format, the exact confidence numbers, the Python API calls) are illustrative. They're a useful way to picture the concept, but they're not documented Honcho or Hermes features. I've flagged those as we go.

Beyond Key-Value Memory

Plain memory systems store facts:

• "User prefers Python"
• "User works at Acme Corp"
• "User's favourite colour is blue"

Those are flat statements. They don't say how the assistant learned them, how much to trust them, or what should happen when fresh information cuts against an old belief.

The richer version of the same memory might look more like this (the confidence figures here are illustrative, not literal Honcho output):

• "User prefers Python" (confidence: 0.9, source: multiple explicit statements, contradictions: none)
• "User works at Acme Corp" (confidence: 0.7, source: mentioned in email, contradictions: LinkedIn says Beta Inc, unresolved tension)
• "User's favourite colour is blue" (confidence: 0.4, source: mentioned once in joke context, contradictions: user owns mostly green clothes)

The Dialectic Model

Honcho's memory works through dialectic reasoning rather than plain lookup: it analyses conversations after they happen through a question-and-answer process and draws structured conclusions about a user's preferences, habits, and goals, instead of just pulling back similar chunks of text the way a vector store does.

One way to picture that, though it's the author's gloss rather than how Honcho's own docs frame it, is the old thesis, antithesis, synthesis pattern from Hegelian dialectics. Applied to building a model of a user:

Thesis: An initial belief. "User prefers concise answers."

Antithesis: New information that cuts against it. "User asked for a detailed explanation with examples."

Synthesis: A refined view that holds both. "User prefers concise answers for simple questions but detailed explanations for complex topics."

In Honcho's actual implementation this analysis runs after a conversation, with configurable depth settings, rather than as an explicit Hegelian engine. The point stands either way: every interaction gets weighed against what's already known, and contradictions become something the agent works to resolve over time rather than facts it silently overwrites.

Tension Records

The "tension record" below is an invented illustration, not a documented Honcho feature, but it shows the idea well. When a system like this spots a contradiction, the better move is to record the conflict rather than blindly overwrite the old belief:

Belief: "User prefers Python over JavaScript"
Confidence: 0.85
Sources: [conversation_123, conversation_145, conversation_201]

TENSION DETECTED:
New observation: "User spent 3 hours debugging a Node.js application"
Contradiction strength: 0.6
Status: UNRESOLVED

Possible resolutions:
1. User uses both languages (confidence: 0.5)
2. User was forced to use Node.js (confidence: 0.3)
3. User's preference has changed (confidence: 0.2)

Next action: Seek clarification on language preferences

A record like that gives the agent a reason to ask instead of assume. That's the behaviour worth copying: when the evidence is mixed, surface the conflict rather than paper over it.

Confidence Evolution

The same illustrative model tracks confidence that shifts over time:

Initial observation: Low confidence (0.3-0.5). A single data point. Repeated confirmation: Confidence rises (0.6-0.8). Several consistent observations. Long-term consistency: High confidence (0.8-0.95). Stable across many interactions. Contradiction detected: Confidence drops, a tension record is created. Resolution: Confidence might climb with a refined view, or fall if the belief turns out to be wrong.

The specific numeric bands here aren't documented Honcho behaviour, but the principle is sound: an agent shouldn't act hard on weak evidence, and it should let beliefs change when the situation does.

Source Attribution

A useful belief should carry source attribution, where the information came from:

• Direct user statement: highest confidence
• Inferred from behaviour: medium confidence
• Third-party data (email, file): lower confidence, plus privacy considerations
• Derived from other beliefs: confidence depends on the beliefs underneath it

(As with the confidence bands, this exact tier scheme is a conceptual description rather than something spelled out in Honcho's docs.) Tracking sources buys you a few things that matter:

• Explainability: the agent can say why it believes something
• Correction: if a source turns out to be wrong, anything derived from it can be re-checked
• Privacy: a source can be deleted or anonymised without throwing away the insights drawn from it
• Verification: users can review and correct their own model

The User Model API

Here's roughly how a developer might want to query a user model. Note that this code is illustrative, these particular function names don't exist in Hermes. The real interface exposes Honcho through tools like honcho_profile, honcho_search, honcho_context, honcho_reasoning, and honcho_conclude, and Honcho's own SDK uses calls such as peer.chat(), session.context(), and peer.search().

# Query the user model
model = hermes.get_user_model("alice")

# Get beliefs about a topic
beliefs = model.query_beliefs(topic="programming languages")
# Returns ranked beliefs with confidence and sources

# Get unresolved tensions
tensions = model.get_tensions()
# Returns contradictions that need resolution

# Get confidence trajectory
confidence = model.confidence_history("preferred_language")
# Shows how confidence has evolved over time

The shape of the idea is what counts: give developers a way to read the user model so they can build experiences that respond to it.

Practical Benefits

The dialectic approach buys you a few concrete things:

Accuracy: models stay closer to the truth because contradictions get tracked and resolved instead of ignored.

Adaptability: people change. A system like this notices and adjusts rather than clinging to stale beliefs.

Explainability: the agent can account for its understanding, which earns trust.

Personalisation depth: instead of a flat list of preferences, you get a model that captures how someone behaves differently depending on context.

There's published evidence the underlying approach holds up. On the LongMemEval-S benchmark, Plastic Labs reports Honcho answering correctly 90.4% of the time while using a median of 5% of the available context per question, against a Claude Haiku 4.5 baseline of 62.6%.

Comparison with Other Systems

vs Vector DB Memory: vector databases store text chunks. Honcho stores structured conclusions with reasoning behind them.

vs Mem0: Mem0 is a general-purpose memory system with multi-layer storage. Honcho is aimed specifically at modelling the user through dialectic reasoning. The two can sit side by side, Mem0 for general memory, Honcho for user understanding.

vs OpenClaw's Session Memory: Plastic Labs maintains an OpenClaw, Honcho integration, and OpenClaw's memory is, by some accounts, primarily session-based (this characterisation is unconfirmed). Honcho's memory is built to persist and evolve across sessions.

The Future

Honcho's reported roadmap points toward a few things, though none of these are confirmed on an official roadmap, so treat them as forward-looking rather than committed:

• Multi-user models: understanding the relationships between users, team dynamics, who reports to whom
• Predictive modelling: anticipating needs from observed patterns
• Cross-device sync: a consistent user model wherever someone works
• User control: interfaces to view, edit, and export your own model

Honcho is a genuinely different take on agent memory, one that treats understanding a person as ongoing work rather than a stack of saved facts. The headline examples around it are more polished than the docs, so it pays to separate the real foundations (the dialectic reasoning, the official Hermes integration, the LongMemEval-S result) from the illustrative dressing. Strip that back and there's still a serious idea here worth watching.