Run Hermes + OpenClaw + Claude Code and you have three independent memory systems. Each agent learns your preferences separately. Each agent has its own embedding index. Each agent forgets the moment it restarts. The "memory" you thought was shared is actually three per-agent silos, and the moment you switch clients, you start over.

Honcho is the channel's recommended cross-platform fix. It is a memory layer that sits between you and the agent — native in Hermes, installable as a plugin in OpenClaw and Claude Code — that intercepts every message, runs reasoning on a token-budget cadence, and uses a "sleep" pass to promote useful context into a profile: who you are, what you like, how you want to be interacted with. The interesting part is that it profiles people you mention, not just you — the host's example is that Honcho will surface context like "hey, let's not send her flowers this time" if it knows you have had a hard time with your girlfriend.

This article is the most ambitious of the three memory fixes (alongside §5.3 embeddings and §5.7 Obsidian). The trade-off is cost and privacy: Honcho's hosted tier is paid, and the profile-of-people-you-mention behaviour is a privacy surface. The payoff is cross-agent consistency — one profile that follows you across Hermes, OpenClaw, and Claude Code.

The source files are 39-honcho-memory-solution.md (full) and the migration material from 2NbfOOD2i1E (Hermes vs OpenClaw, the cross-listed memory-migration video). The §5.6 capstone is built around the four-step integration: Hermes (native), OpenClaw (plugin), Claude Code (plugin), and the cross-platform profile that emerges.

What you'll learn

  • The traditional memory stack (per-agent embeddings + QMD + skills) is platform-locked. OpenClaw's memory does not follow you to Hermes; Hermes' memory does not follow you to Claude Code.
  • Honcho is a memory layer that sits between you and the agent — native in Hermes, installable as a plugin in OpenClaw and Claude Code — that intercepts every message and routes through a single cross-platform profile.
  • The reasoning engine is a model called Neuromancer that Honcho's team built specifically for memory reasoning — "specifically trained for understanding humans and understanding how you like your preferences and then updating that as time progresses."
  • Honcho's distinctive feature is multi-person profile building: it tracks not just you, but people you mention. "My girlfriend Sarah loves roses" plus "Sarah and I are having issues" → next suggestion is "maybe skip the flowers this time."
  • The cross-platform profile covers personal preferences, work patterns, relationship context, and historical decisions. One profile, three agents.
  • The pricing split: paid tier = easy install, Neuromancer does the work; free self-host = you wire it into OpenClaw and look at the JSON/dream files yourself.
  • The privacy surface is real. Honcho intercepts every message — every conversation, every preference, every relationship detail. Decide explicitly what is in and out of the profile.

The multi-agent problem Honcho solves

From 39-honcho-memory-solution.md:

OpenClaw Agent: "I learned you like pepperoni pizza"
Hermes Agent:   "What kind of pizza do you like?"
Claude Code:    "What kind of pizza do you like?"

[You have to teach each one separately]

Three agents, three separate memory systems, three independent forgetting cycles. Each one learns your preferences from scratch. None of them share what they have learned. The moment you switch clients, you start over.

The traditional memory stack (per-agent embeddings + QMD + skills) is platform-locked by construction. OpenClaw's memory lives in ~/.openclaw/memory/memory.db. Hermes' memory lives in ~/.hermes/. Claude Code's memory is its own. There is no cross-platform bridge in any of them.

Honcho's architectural answer:

You ↔ Honcho ↔ OpenClaw
              ↔ Hermes
              ↔ Claude Code

[One memory system, multiple agents]

Every message hits Honcho before it hits the agent. Honcho updates the cross-platform profile. The agent receives a context-enriched version of your message that includes the relevant pieces of the profile. The result: one memory, three agents.

The Neuromancer reasoning model

Honcho's reasoning engine is a model called Neuromancer that Honcho's team built specifically for this — "specifically trained for understanding humans and understanding how you like your preferences and then updating that as time progresses." Neuromancer is not open source; the rest of Honcho is.

What Neuromancer does:

  • Analyses every message you send.
  • Extracts factual information.
  • Updates your profile intelligently.
  • Cheaper than using Opus for memory processing.

Example from 39-honcho-memory-solution.md:

You: "I'm on a keto diet now, no more carbs"
Neuromancer: [Updates profile]
  - Previous: User likes pepperoni pizza
  - New: User is on keto diet (recent preference)
  - Action: Prioritize keto preference over pizza preference

The automatic memory promotion (Honcho's "dreaming" pass) handles preference changes over time:

6 months ago: "I love pineapple on pizza"
Last week:     "Actually, I hate pineapple on pizza now"

Honcho: [Demotes old preference, promotes new one]
Next order: No pineapple (uses recent preference)

This is the structural answer to "I changed my mind last week and the agent still recommends the old thing." Without Neuromancer-style reasoning, the agent has no mechanism for preference changes — both preferences sit in the index with equal weight, and the older one wins by default.

Multi-person profile building

Honcho's distinctive feature is multi-person profile building — it tracks not just you, but people you mention. From 39-honcho-memory-solution.md:

You: "My girlfriend Sarah loves roses"
[Later, after a fight]
You: "Sarah and I are having issues"

Honcho: [Remembers relationship context]
Agent: "Maybe skip the flowers this time?"

This is the example the channel uses to illustrate the difference between "memory for documents" (what an embedding index does) and "memory for people" (what Honcho does). A vector index would return documents about flowers; Honcho returns context about your relationship.

The same pattern works for work relationships:

You: "My boss Jane prefers formal weekly reports."
You: "Jane and I had a tense 1:1 this week."
[Next request for a status update]
Honcho: [Surfaces "Jane prefers formal", recent conflict]
Agent: [Suggests more diplomatic phrasing than the casual draft]

The category shift is real. "Memory for people, not memory for documents" is the framing the channel uses. Whether that is a feature you want is a separate question — it is also a privacy surface, and you should think about it explicitly (see the Privacy section below).

How Honcho works in practice

Hosted service (recommended):

  1. Visit Honcho website.
  2. Create an account.
  3. Get your API key.
  4. Note: this is a paid service.

Self-hosted (advanced):

  • Honcho is open source.
  • Can run on your own infrastructure.
  • Neuromancer reasoning model is NOT open source.
  • More privacy but more setup complexity.

Integration with Hermes (native):

# In your Hermes configuration
honcho_enabled: true
honcho_api_key: "your-api-key-here"

That's it. Hermes will automatically:

  • Send all conversations to Honcho.
  • Retrieve relevant memories when needed.
  • Update your profile over time.

Integration with OpenClaw (plugin):

# Install Honcho plugin for OpenClaw
openclaw plugin install honcho

# Configure with your API key
openclaw config set honcho.api_key "your-api-key-here"
openclaw config set honcho.enabled true

Integration with Claude Code (plugin):

# Configure Claude Code to use Honcho
claude-code config set memory.provider honcho
claude-code config set memory.honcho.api_key "your-api-key-here"

After integration, every message you send to any of the three agents hits Honcho first. The cross-platform profile updates. The agent receives context-enriched input that includes the relevant pieces of the profile.

Cost considerations

Per-message processing:

  • Neuromancer analyses each message.
  • Cheaper than Opus-level reasoning.
  • Costs scale with usage.

Compare to alternatives:

Approach Cost Privacy Cross-platform
OpenAI embeddings Pay per embedding + storage Local No
Self-hosted QMD Free but requires infrastructure Local No
Honcho hosted Pay per message Cloud Yes
Honcho self-hosted Free infra + setup Local Yes

The channel's framing is direct: "if you're willing to pay, you get a better experience. If you're not willing to pay, you still get a good experience, but you just have to look at the memory files."

When Honcho is worth it

Good fit:

  • You use multiple AI platforms (Hermes + OpenClaw + Claude Code, or any two of the three).
  • You want automatic memory management.
  • You value cross-platform consistency.
  • You don't want to manage memory manually.

Not worth it:

  • You only use one agent. Single-agent setups do not benefit from cross-platform profiles.
  • You prefer manual memory management. The Obsidian + GitHub pattern (§5.7) gives you more control.
  • You want complete privacy. Use self-hosted Honcho or a local Obsidian vault.
  • You're on a tight budget. The hosted tier is per-message; costs add up.

Privacy considerations

What Honcho sees:

Honcho intercepts all messages. Every conversation with every agent. Personal information. Relationship details. Work information. Preferences and habits. The cross-platform profile is comprehensive by design — that is the feature.

Privacy options:

Option 1 — trust the hosted service:

  • Convenient.
  • Fully managed.
  • Data stored on Honcho servers.

Option 2 — self-host:

  • Complete privacy.
  • You control the data.
  • More setup complexity.
  • Neuromancer model not included (use alternative reasoning).

Option 3 — hybrid approach:

  • Use Honcho for work agents.
  • Use local memory (Obsidian + embeddings) for personal agents.

The hybrid approach is the channel's recommendation for users who handle sensitive context. The trade-off is partial loss of cross-platform consistency — but the work profile and the personal profile stay separate.

Cross-platform profile structure

Your Honcho profile includes:

  • Personal preferences — food, style, communication.
  • Work patterns — how you like reports, code style, meeting cadence.
  • Relationship context — team members, family, contacts you mention.
  • Historical context — past decisions, lessons learned, project history.

The profile is the cross-agent source of truth. When you switch from OpenClaw to Hermes, the new agent does not start from zero — it receives the Honcho profile as part of its bootstrap.

Automatic context adaptation

Honcho understands context changes:

Morning: "I need coffee, strong and black"
Evening: "I'm trying to sleep better"

Honcho: [Doesn't suggest coffee in the evening]

The same preference (you like coffee) is contextualised by time of day. The agent's recommendations change accordingly. This is the same Neuromancer reasoning that handles the "keto diet overrides pepperoni pizza" case from earlier — but applied to temporal context rather than preference evolution.

Relationship-aware interactions

Honcho tracks how you interact with different people:

With boss:    Formal, detailed reports
With team:    Casual, quick updates
With clients: Professional, concise

[Each agent adapts based on who you're communicating with]

This is the multi-person profile applied to communication style. The agent does not just know what you like — it knows what register to use for the audience you are addressing.

Comparison: Honcho vs. traditional memory

Feature Traditional memory Honcho
Cross-platform No Yes
Automatic updates Manual Automatic
Preference changes Keeps old data Promotes new
Relationship context No Yes
Privacy Local Cloud (or self-host)
Cost Embedding costs Per-message
Setup complexity Medium Easy (hosted)

The two columns are not mutually exclusive. You can run Honcho as the cross-platform profile layer and Obsidian + embeddings as the long-term memory layer underneath. The two systems serve different purposes.

Prevention tips

  1. Review your profile regularly. Check what Honcho has learned. Correct misunderstandings before they compound.
  2. Be explicit about changes. "I used to like X, but now I prefer Y" — Honcho's Neuromancer handles this, but explicit corrections speed the update.
  3. Consider privacy implications. Decide what information you are comfortable sharing. The hosted tier sees everything.
  4. Monitor costs. Track usage to ensure it fits your budget. Per-message pricing scales with how much you use the agent.
  5. Test the cross-platform handoff. Switch from OpenClaw to Hermes mid-task. Verify the new agent has access to the Honcho profile and is not starting from zero.

Try it yourself

The hands-on goal: prove Honcho's cross-platform profile works across two of your installed agents.

  1. Sign up for Honcho hosted (or self-host). Get the API key.
  2. Install on two agents — for example, OpenClaw and Hermes. Use the install commands from above.
  3. Have a preference-stating conversation with agent A. Tell OpenClaw "I prefer Pepsi diet with ice, not Coke." Confirm the message hits Honcho.
  4. Switch to agent B. Open Hermes. Ask: "What's my soda preference?" A correctly-integrated Honcho returns the Pepsi preference from the OpenClaw conversation.
  5. Test the Neuromancer preference update. Tell Hermes "Actually, I'm on a keto diet now, no more carbs." Then ask OpenClaw for food recommendations. The keto preference should override older food preferences in the profile.
  6. Test the relationship-aware suggestion. Tell Hermes about a friend you are having a conflict with. Then ask OpenClaw to suggest a gift. The suggestion should account for the conflict.
  7. Audit the profile. Use Honcho's dashboard to see what the cross-platform profile actually contains. Correct anything that is wrong.

Common pitfalls

  • Using Honcho on a single agent. If you only run OpenClaw (or only Hermes), the cross-platform value is zero. Use a local memory layer instead (§5.3 embeddings, §5.7 Obsidian).
  • Trusting the profile without auditing. Neuromancer is reasoning, not ground truth. It can extract the wrong preference or miss a context shift. Review the profile regularly.
  • Routing sensitive context through the hosted tier. Relationship details, financial information, medical context — the hosted tier sees all of it. Use self-host or hybrid for sensitive categories.
  • Assuming Honcho replaces local memory. It does not. Honcho is the cross-platform profile layer; embeddings (§5.3) and Obsidian (§5.7) are the long-term memory layer. The two compose.
  • Not testing the cross-platform handoff. Set up Honcho, then verify that switching agents actually carries the profile. Silent integration failures are the worst kind.
  • Letting the profile grow without bounds. Old preferences, retired relationships, completed projects — clean up the profile periodically. The §5.5 audit-once-a-month rule applies to Honcho profiles too.
  • Ignoring the Neuromancer-no-open-source caveat. Self-hosted Honcho does not include Neuromancer. You get the storage and routing without the reasoning. For the full experience, use the hosted tier.

Sources

  • Honcho Just SOLVED the AI Memory Problem — 1,083 views · dp_MeH3-Kbs · the cross-platform pitch, Neuromancer reasoning, and privacy trade-off.
  • Hermes vs OpenClaw: Why Everyone Is Migrating — 6,116 views · 2NbfOOD2i1E · the migration script that moves soul.md + memories + settings between agents — the practical path to sharing one profile across platforms.
  • Source files consolidated into this article: 39-honcho-memory-solution.md (full file — the cross-platform pitch, Neuromancer reasoning model, multi-person profile building, hosted vs. self-host cost analysis, privacy considerations).

External tools and services referenced: Honcho hosted API + dashboard, Honcho open-source self-hosted variant (Neuromancer not included), Neuromancer reasoning model (Honcho's proprietary model for memory reasoning), the Hermes native integration (honcho_enabled: true), the OpenClaw plugin (openclaw plugin install honcho), the Claude Code memory provider config (memory.provider honcho), and the cross-platform profile that emerges across all three integrations.