---
title: "How Honcho Memory Makes Hermes Agent Actually Remember Your Business"
url: https://ishchuk.eu/blog/how-honcho-memory-makes-hermes-agent-actually-remember-your-business
published: 2026-09-16T18:07:05.000Z
updated: 2026-09-16T18:07:08.461Z
tags: [hermes-agent, honcho, ai-agents, agent-memory, ai-automation]
---

# How Honcho Memory Makes Hermes Agent Actually Remember Your Business

Most AI agents forget everything the moment you close the chat window. Hermes Agent fixes half of that out of the box with two small local files, and fixes the other half by plugging into Honcho, a memory layer from Plastic Labs that stores your history and then reasons over it - so the agent stops asking you to re-explain your business every Monday. The short version: Hermes' built-in MEMORY.md and USER.md give you ~1,300 tokens of always-on context, and Honcho adds unlimited, cross-session memory that learns who your clients are, how you price, and what you've already decided, without you repeating any of it.

I run this exact stack, so this piece comes with opinions. Here's how the two layers fit together, what setup looks like, and what it costs.

## What Built-In Memory in Hermes Agent Actually Does

Hermes Agent is an open-source autonomous agent built by Nous Research ([docs here](https://hermes-agent.nousresearch.com/docs)). It runs on your machine or a $5 VPS, talks to you over Telegram or Discord, and ships with persistent memory by default - no external service, no database to babysit.

The built-in layer is two files in `~/.hermes/memories/`:

- MEMORY.md - the agent's own notebook. Environment facts, project conventions, tool quirks, lessons it learned the hard way. Capped at 2,200 characters, roughly 800 tokens.
- USER.md - your profile. Role, timezone, communication style, pet peeves. Capped at 1,375 characters, about 500 tokens.

At the start of every session, both files load off disk and get injected into the system prompt as a frozen snapshot. Entries are separated by a section-sign delimiter, and the header shows capacity usage - my own MEMORY.md sits at 67% right now, which the agent can see and act on. When memory is full, the write fails loudly instead of silently dropping entries, and the agent has to consolidate before retrying. That design choice matters more than it sounds: an agent that quietly forgets your pricing rules is worse than one that admits it's out of room.

The agent edits these files itself through a `memory` tool (add, replace, remove - replace and remove work on substring matches, so no exact-entry bookkeeping). You can gate that with `write_approval: true` if you want to review saves before they stick, which I'd recommend early on. A wrong assumption about your business, persisted, compounds.

There's also session search: every CLI and messaging session is stored in SQLite with FTS5 full-text search, so the agent can pull up what you discussed three weeks ago even when it never made it into active memory. That's free - no LLM calls, ~20ms per query.

So where's the gap? Two files totaling ~1,300 tokens are a summary, not a history. You get the bullet-point version of your business, not the accumulated detail.

## Where the Built-In Memory Runs Out

Here's the failure mode for a small business owner. Week one, you tell the agent about your five biggest clients, your pricing tiers, the fact that one client always pays late. Week six, you ask it to draft a proposal and it has the one-line version of all that - because USER.md ran out of characters somewhere in week three.

This isn't a Hermes defect. Small bounded memory is the right default: it keeps the system prompt cheap and forces curation. But bounded memory and a growing business pull in opposite directions, and at some point you're curating your agent's memory like a second job. That's the moment to add a memory provider.

## What Is Honcho and How Does Its Dialectic Memory Work?

Honcho is a memory API for stateful agents, built by Plastic Labs (the lab behind it - [honcho.dev](https://honcho.dev), open source core at [github.com/plastic-labs/honcho](https://github.com/plastic-labs/honcho)). The definition that matters: it stores every message, then a reasoning engine (their custom Neuromancer models) continually extracts conclusions from them - patterns, preferences, relationships, hypotheses - rather than just indexing text chunks for similarity search. That reasoning-over-recall approach is what they mean by dialectic memory.

Concretely, three things happen. Ingestion: every message you send is stored and reasoned over automatically, fast enough (~200ms) to run every turn. Context: calling `context()` returns a curated bundle - session summary, user representation, relevant history - sized to a token budget you set. Dialectic queries: the agent can ask Honcho natural-language questions about you ("what does this user care about in contract negotiations?") and get synthesized answers, not retrieved chunks.

Benchmarks, from Honcho's published evals at [evals.honcho.dev](https://evals.honcho.dev) (LongMem 89.9%, LongMem S 90.4%): state-of-the-art scores on long-horizon memory. Take vendor benchmarks as you find them, but the benchmark code is open on GitHub, so the numbers are independently runnable.

## How Hermes and Honcho Work Together

Hermes ships Honcho as one of eight external memory provider plugins (Mem0, Hindsight, and others are in there too). When you activate it, Hermes does the plumbing automatically: it syncs conversation turns to Honcho after each response, prefetches relevant memories before each turn in the background, injects Honcho's context into the system prompt, and mirrors built-in memory writes so your MEMORY.md entries also land in Honcho. The built-in files keep working - the provider is additive, not a replacement.

The agent also gets five Honcho tools it can call directly: profile (read/update your peer card), search (semantic search over history), context, reasoning (LLM-synthesized answers about you), and conclude (write durable conclusions).

Setup is one command, `hermes memory setup`, pick Honcho, authenticate. On a remote box without a browser it offers a device-code flow instead of key copy-paste - a small thing, but it tells you someone actually used this over SSH.

The knob I'd point a cost-conscious owner at: `contextTokens`. Honcho can inject unlimited context per turn; you probably don't want that. Set a budget and it truncates at word boundaries.

## Why a Business Owner Should Care

The honest framing is this: everything Honcho gives you, you could theoretically get by pasting a huge brief into every conversation. Nobody does that. So the real product is compliance - the context that should be there, actually being there, every session.

A few places where that pays off concretely:

- Client communications. The agent that remembers a client's tone, past decisions, and open threads drafts follow-ups that don't read like they came from a new hire.
- Pricing consistency. Your rules for discounting, payment terms, and escalation persist instead of living in one prompt you forgot to reuse.
- Long projects. Week twelve of a project, the agent still knows what was decided in week one, because the decision is a conclusion in memory, not a line item you cut for space.
- Token spend. Honcho's pitch is 60-90% token savings versus stuffing full history into context - you ask for the 10K relevant tokens instead of paying for 100K of transcript. Whether you hit the top of that range depends on your usage, but the direction is right.

One digression, because it cost me an hour: Honcho workspaces and peer IDs must match across machines. If you set it up on your laptop and then configure a server instance fresh, you can end up with orphaned memory - everything writes fine, nothing connects to your existing history. Check the workspace and peer names in the config before you assume amnesia is a bug.

## What It Costs: Cloud vs Self-Hosted

Honcho's cloud pricing, per their published page:

- Ingestion (storage plus reasoning): $2.00 per million tokens, with context() retrieval included
- Dialectic queries: tiered from $0.001 for an instant single lookup up to around $0.50 for deep, async research-grade synthesis - the low default tier is $0.01
- Startups under $5M raised get $1,000 in credits and subsidized pricing for a year

For a solo business user, realistic monthly spend is single-digit dollars unless you're hammering deep-reasoning queries. The variable to watch is dialectic depth, not ingestion.

Self-hosting is the other path: Honcho's core is open source (github.com/plastic-labs/honcho), and community self-host recipes exist. Free in license, real in operational cost - you're now running a memory service, its database, and the inference the deriver needs. For most one-person companies, imo, the cloud at $2/M tokens is cheaper than the sysadmin time. Self-host makes sense when client data can't leave your infrastructure, or you already run a box with spare GPU.

The default self-hosted recipes use a small fast model for the derivation step, which keeps that side cheap. The reasoning tier you pick per query is where the real cost lives either way.

## Should You Turn This On?

If you use Hermes Agent for anything weekly, yes. The built-in files carry you through week two; Honcho is what makes month three feel like the agent has been at your company since day one. Run both: MEMORY.md for the dozen facts that must never leave the prompt, Honcho for everything accumulating underneath. And if you're evaluating agents generally, use memory architecture as a filter - an agent without persistent memory isn't a hire, it's a temp that re-interviews every morning.

---

*This article is part of a series on running AI agents in small businesses. I build these systems for a living - if you want a memory-backed agent set up for your operation, [get in touch](https://ishchuk.eu).*


## FAQ

### What is the difference between Hermes Agent's built-in memory and Honcho?

Hermes Agent ships with two small local files, MEMORY.md and USER.md, capped at about 1,300 tokens combined, that are injected into every session's system prompt for always-on context. Honcho is an external memory provider that stores unlimited conversation history and reasons over it, extracting conclusions about you and your business across sessions. The built-in memory is a bounded summary; Honcho is the full accumulating history underneath it, and the two run side by side.

### How much does Honcho memory cost?

Honcho's cloud pricing is $2.00 per million tokens ingested, which includes storage, retrieval, and background reasoning. Dialectic queries are tiered by reasoning depth, from $0.001 for an instant lookup to around $0.50 for research-grade synthesis, with $0.01 as the default tier. Startups under $5M raised get $1,000 in credits. A typical solo business user spends single-digit dollars per month. Self-hosting the open-source core is free in license but carries real server and maintenance costs.

### How do I set up Honcho memory with Hermes Agent?

Run 'hermes memory setup', select Honcho, and authenticate with an API key from app.honcho.dev or a device-code flow on remote machines. Hermes then automatically syncs conversation turns to Honcho, prefetches relevant memories before each turn, and injects Honcho context into the system prompt. The built-in MEMORY.md and USER.md keep working alongside it, so no migration is needed.

### Does Hermes Agent remember things between sessions without Honcho?

Yes. Hermes Agent persists two memory files across sessions by default: MEMORY.md for the agent's own notes about your environment and projects, and USER.md for your preferences and communication style, together holding roughly 1,300 tokens. It also stores every past session in SQLite with full-text search, so it can look up what you discussed weeks ago. The limits are capacity, not persistence.

### What is dialectic memory in Honcho?

Dialectic memory is Honcho's approach of reasoning over stored conversations rather than just retrieving similar text chunks. Every message is analyzed by custom reasoning models that extract conclusions, patterns, and hypotheses about the user. When the agent queries Honcho, it gets synthesized answers informed by everything learned, at a reasoning depth you select per query, from instant lookups to deep async synthesis.

### Can Honcho reduce AI agent token costs?

Honcho reports 60-90% token savings by returning a curated, budgeted slice of relevant context instead of stuffing full conversation history into the model's context window. In Hermes Agent you control this with the contextTokens setting, which caps how much Honcho context is injected per turn. Actual savings depend on usage volume and how large your raw history would otherwise be.