Blog

Hermes Agent memory providers: what they learn and miss

Aperisa · 7 min read

After each response, Hermes syncs the conversation turn to your memory provider. Nothing in that lifecycle reads your inbox.

Hermes Agent memory providers are external plugins, such as Honcho, Mem0, Hindsight or Supermemory, that add long-term memory on top of the built-in MEMORY.md and USER.md. One can be active at a time. Hermes prefetches from it before each turn and syncs to it after each response. That makes providers good at learning from conversations. The facts your agent gets wrong mostly live in documents, so our view is simple: run a provider for memory, and give the agent a separate record of facts it can query as a tool.

How do Hermes Agent memory providers work?

The Hermes memory providers docs describe the same lifecycle for every provider. With one active, Hermes:

1. Injects provider context into the system prompt.
2. Prefetches relevant memories before each turn, in the background, without blocking.
3. Syncs conversation turns to the provider after each response.
4. Extracts memories at session end, for providers that support it.
5. Mirrors built-in memory writes to the provider.
6. Adds the provider's own tools.

One detail worth knowing before you pick a cloud option: data sent to a provider (turns, tool output, memory writes) first goes through the same secret scrub Hermes uses for chat and cron delivery, even with security.redact_secrets: false. The docs add that credentials without a recognizable shape aren't detected.

Read the inputs in that list again. Turns, tool output, memory writes. A provider sees what passes through the agent. Prefetch is only as good as what was synced.

Which memory providers does Hermes Agent support?

Nine, per the docs. Here's what each one is, in the docs' own terms. We haven't tested any of them, so this isn't a ranking.

The same page says RetainDB and ByteRover were set to leave core on October 15, 2026, and that their standalone repositories are unmaintained. Check the current docs before you build on either.

How do you set up a Hermes memory provider?

hermes memory setup gives you an interactive picker. Or set it in ~/.hermes/config.yaml:

memory:
  provider: mem0

Catalog providers need installing first, for example hermes plugins install mem0. Credentials go where each provider's section says. For Mem0 that's MEM0_API_KEY in ~/.hermes/.env, with config in $HERMES_HOME/mem0.json. Honcho reads $HERMES_HOME/honcho.json. Then:

hermes memory status   # what's active
hermes memory off      # disable the external provider

Each provider adds its own tools: mem0_search and mem0_add, honcho_profile and honcho_search, hindsight_recall and hindsight_reflect, and so on. Those are worth reading before you choose, because they tell you what the agent can actually do with its memory.

What do Hermes memory plugins learn from, and what do they miss?

Providers differ in how they store and retrieve. They share the same feed: the conversation, the agent's tool output, and its memory writes.

To be fair to them, some providers go further. RetainDB lists file tools such as retaindb_upload_file and retaindb_ingest_file. OpenViking has viking_add_resource. So "providers only know chat" isn't quite right. The accurate version is that a document gets in when someone, you or the agent, puts it in. And it stays at the version that went in.

Now look at where the facts that trip up an agent live. With made-up data:

• The client's payment terms are net 45, in section 6 of a signed agreement in Drive.
• An email last Tuesday moved the kickoff from the 3rd to the 10th.
• A change order raised the monthly retainer from $4,000 to $4,600.

None of those arrived in a conversation with the agent. If you mentioned the old retainer in chat once, the provider learned $4,000, faithfully. When the change order lands in your inbox, nothing in the lifecycle tells the provider. Prefetch keeps surfacing $4,000, because that's what it was given.

That's not a defect in any provider. It's a different job. Memory captures what happened between you and the agent. A record of facts tracks what your documents say now.

The record-of-facts pattern next to a provider

The pattern is two sources with two jobs, in one config file. The provider stays as memory. A read-only MCP server over your documents becomes the place the agent looks up facts. Hermes supports both side by side in ~/.hermes/config.yaml, per the Hermes MCP docs. With a made-up records server:

memory:
  provider: honcho

mcp_servers:
  records:
    url: "https://records.example.com/mcp"
    tools:
      include: [search_records, get_document]

The include list is an allowlist, so the agent only gets the read tools. Hermes registers them as mcp_records_search_records and mcp_records_get_document. Run /reload-mcp to pick up the change mid-session.

Then write the routing rule down where the agent always sees it, such as a MEMORY.md entry:

Amounts, dates, terms, contacts: look up with mcp_records and cite the document.
If memory and the record disagree, use the record and say so.

That second line does the real work. Prefetch will still bring back "$4,000" from an old conversation. The agent now treats it as a hint, checks the record, and finds the change order. You get $4,600 and a link to the document that says so.

Each source does what it's good at. The provider remembers that you want invoices drafted on the 25th and sent as PDFs. The record knows what the invoice should say.

How should you compare Hermes Agent memory options?

Read each provider's own docs and ask:

• Where does it store data: local file, your server, or their cloud?
• What does it extract from a turn, and can you see and edit what it kept?
• Does it run extraction at session end, and what does that cost in model calls? Honcho, for example, exposes cadence and depth settings for cost control.
• What tools does it add, and do any of them write or delete?

And ask one question of the whole setup: when your agent states a number, can you click through to where it came from?

Where does Aperisa fit?

Aperisa is one example of a record of facts. It reads Gmail, Drive, Calendar and Contacts with read-only Google access, plus the bank accounts you link, and keeps a searchable copy to answer from. It maps those records into one structured record and serves it through a read-only remote MCP server with no send, write or delete tools. It looks up your records instead of asking a model to recall them, and answers come with the email or document they came from.

Pick a provider for memory, not for facts

Choose a Hermes memory provider on how it learns from your conversations, because that's the job all nine are built around. For what your documents say, give the agent a separate record it can query, and a rule to trust the record when the two disagree. For how the built-in files fit in, see our guide to Hermes Agent memory.

Aperisa connects as a remote MCP server over Streamable HTTP with a Bearer key, and each key can be limited by data area and level of detail. Try it out.

FAQ

Which memory providers does Hermes Agent support? The Hermes docs list Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, ByteRover, Supermemory and Memori. The docs list RetainDB and ByteRover as bundled (both were set to leave core on October 15, 2026), Memori needs an external CLI, and the rest install from the plugin catalog.

Can I run Honcho and Mem0 at the same time in Hermes? No. Only one external memory provider can be active at a time. The built-in MEMORY.md and USER.md stay active alongside whichever provider you choose.

How do I switch Hermes memory providers? Run hermes memory setup for the interactive picker, or set memory.provider in ~/.hermes/config.yaml. Catalog providers need hermes plugins install first. hermes memory status shows what's active and hermes memory off disables the provider.

Does a Hermes memory provider read my documents? The documented lifecycle syncs conversation turns, tool output and memory writes to the provider. Some providers add tools for adding files or resources, but someone has to put each document in and keep it current. A lookup tool over your documents does a different job.

Sources

• Hermes Agent memory providers docs
• Hermes Agent memory docs
• Hermes Agent MCP docs

Published October 26, 2026