Source: ai-research/agentwikis-hermes-memory-providers-2026-06-12.md — compiled by Agent Wikis from official v0.16.0-era docs; sourced 2026-06-12; community field signals raw/reddit-1u8fm0t.md, raw/reddit-1u9zkkj.md, raw/reddit-1v4czxp.md
Hermes ships with a built-in memory store and, since v0.7.0, a pluggable memory provider interface that third-party backends implement. Only one external provider is active at a time, running alongside (never replacing) the built-in MEMORY.md/USER.md layer and FTS5 session search. v0.16.0-era docs list 9 external providers. No cross-provider migration — memories don’t migrate between providers, so plan before committing; hermes sessions export before switching is the safety net.
Key Takeaways
- Don’t optimize prematurely — built-in is fine for most solo developers until “repeating context or losing long-term recall” becomes a pattern
- Holographic is now the recommended first upgrade — zero dependencies, one command, no API key, trust-scored facts + contradiction detection; the old advice of jumping straight to a cloud provider no longer holds
- Four architectural styles — document store (built-in), identity modeling (Honcho/Supermemory), structured knowledge (Hindsight/OpenViking/ByteRover), hands-off extraction services (Mem0/RetainDB/Memori)
- “Third-party” no longer means less supported — Hindsight is the most actively maintained third-party provider across Hermes release history; OpenViking carries Volcengine/ByteDance weight
- Field signal — a 3-month daily driver reverted to built-in (2026-06). [Reddit r/hermesagent] An operator who tried “every memory provider connected to Hermes, plus a few open-source ones from GitHub” turned them all off and settled on the built-in markdown USER / MEMORY / SOUL layer (USER + MEMORY short and agent-editable, SOUL immutable), framing the lesson as “agents don’t remember, agents read.” A concrete reversion case behind the “don’t optimize prematurely” recommendation above. (Source:
raw/reddit-1u8fm0t.md.) - Field signal — FTS5-vs-vector token economics (2026-06). [Reddit r/hermesagent] A community Document-Structuring skill (github.com/barnetwang/document_structuring) parses large PDFs/DOCXs into a SQLite FTS5 store — chosen deliberately over a heavy vector DB “to keep it fast and simple” — for targeted chunk retrieval. On a 3,799-page AMD manual (~1.05M words), a single register-lookup query cost ~2.79M tokens via full-text dump (the model hallucinated) versus ~2,244 tokens via FTS5 chunk retrieval (correct answer). ^[single anecdotal local benchmark — Windows 11 / Ollama / Qwen, repo unverified, not a controlled eval] A concrete data point behind the built-in/Holographic FTS5 design choice, though the author tested local-only and asks for cloud-model validation.
Field signal — memory as a token-cost lever (2026-07-23)
[Reddit signal — r/hermesagent 2026-07-23] Source: raw/reddit-1v4czxp.md — a single low-engagement post (15 score, 18 comments, OP u/krrish253, “USE CASE” flair) reporting a self-run audit of his own Hermes install. Every number below is user-reported, from one machine, with no independent verification.
This report is worth recording because it reframes provider choice around a dimension the rest of this article barely touches: what the memory layer costs you in tokens on every single turn, independent of recall quality. The OP installed a three-tool stack on 2026-07-21 and audited it two days later:
| Component | Role | Reported result |
|---|---|---|
| MemPalace | long-term memory; replaces the built-in MEMORY.md injection with on-demand semantic search over a ChromaDB vector store (952KB store, 35.6KB facts DB) | the largest contributor — see below |
| Headroom v0.32.1 | context-compression proxy on 127.0.0.1:8789, in front of an OpenAI-compatible backend (OpenCode Go) | 377,118 tokens compressed away across 55 events; 81.7% of input compressed; 89.66% ratio in the best session; $1.89 saved at DeepSeek pricing |
| RTK v0.43.0 | terminal-output rewriting | negligible — 3 requests, 1,573 tokens; the OP concludes Headroom compresses the same output later anyway |
The specific finding that matters here: the OP measured the built-in memory injection at 8,283 bytes (~2,070 tokens) prepended to the system prompt every turn, versus roughly 200–500 tokens when MemPalace returns only semantically-relevant facts on demand. At his ~30 turns per session that is a claimed ~45K–54K tokens saved per session, which he calls the single biggest driver of his headline number. Whatever the headline’s validity, the per-turn cost of always-on markdown injection is a real, measurable property of the built-in provider — and it is the clearest argument yet for a third upgrade trigger alongside the two this article already names.
A third trigger for leaving the built-in provider. The recommendations above upgrade you when recall fails (“repeating context or losing long-term recall”). This report adds: upgrade when the standing token tax of always-injected memory becomes the dominant line item — a different symptom with a different cure (retrieval-on-demand rather than better recall). Note this does not overturn the 3-month-daily-driver field signal above, where an operator turned every provider off and returned to built-in markdown; the two operators optimized for different things (auditability and “agents don’t remember, agents read” versus tokens per turn), and neither ran the other’s test. ^[inferred — the reconciliation is this wiki’s; neither source addresses the other]
Why the headline number should not be quoted. The OP reports input tokens per session down 84.3% (3.6M → 564K), cost per session down 82.6% (0.09 at DeepSeek pricing), and extrapolates ~$1,100/month savings. Three problems, two of which he raises himself:
- Confounded by same-day config changes. He set
show_reasoning: false(no longer storing reasoning traces as messages) and droppedagent.max_turnsfrom 180 to 50 on the same day, and states these “account for a significant chunk of the 84% drop.” Cutting max turns by 72% mechanically shrinks accumulated context regardless of what the memory layer does. The stack’s isolated contribution is not measurable from this data. - Wildly asymmetric samples. 2,209 sessions before versus 31 after.
- No dollars actually saved. He is on OpenCode Go at $10/month flat, so the reported savings are hypothetical DeepSeek-pricing equivalents. The real, non-hypothetical benefits he claims are ~6–7× more sessions before hitting rate limits and faster inference from smaller contexts.
MemPalace is not in the provider tables above. It appears in no Hermes-docs source this wiki has ingested and is not one of the 9 v0.16.0-era external providers — treat it as a community tool of unknown provenance until verified. Headroom has its own coverage: Headroom (context compression). Note also that Headroom and RTK are not memory providers at all — they compress what flows through the context window, orthogonal to which provider stores facts. The reason they show up in the same audit is that both levers land on the same bill, which is exactly why the OP’s numbers can’t be split cleanly between them.
Cost, Hosting, Trust
| Provider | Hosting | Cost | Trust |
|---|---|---|---|
| Built-in | Local ~/.hermes/ | Free | First-party (Nous) |
| Honcho | Cloud or self-hosted | Cloud metered; self-hosted free | First-party reference plugin |
| OpenViking | Self-hosted only | Free (AGPL-3.0) | Volcengine (ByteDance) |
| Mem0 | Cloud only | Mem0 pricing | Third-party |
| Hindsight | Cloud or local (embedded PostgreSQL) | Cloud paid / local free | Third-party; most actively maintained |
| Holographic | Local only (SQLite) | Free | Official plugin; zero dependencies |
| RetainDB | Cloud only | $20/mo flat | Third-party; only published flat price |
| ByteRover | Local-first; optional cloud sync | Free local / paid sync | Third-party; SOC2 Type II cloud |
| Supermemory | Cloud only | Supermemory pricing | Third-party; added v0.8.0 |
| Memori | Cloud | Free tier + paid | Third-party; new v0.16.0; no entity page yet |
Capability Matrix
| Provider | Retrieval Style | Unique Feature |
|---|---|---|
| Built-in | FTS5 + curated markdown | Always on; human-auditable plain text |
| Honcho | Semantic + dialectic LLM reasoning | Dialectic user modeling; per-profile AI peers; 3 tunable cost knobs |
| OpenViking | Tiered L0 (~100 tok) → L1 (~2k) → L2 (full) | viking:// filesystem hierarchy; first-class URL/doc ingestion |
| Mem0 | Semantic + reranking | Server-side LLM fact extraction with auto-dedup — fully hands-off |
| Hindsight | Semantic + graph + temporal | Knowledge graph + hindsight_reflect cross-memory synthesis |
| Holographic | FTS5 + HRR compositional algebra | probe/reason/contradict algebraic queries; trust scoring |
| RetainDB | Hybrid: vector + BM25 + reranking | Delta compression; 7 memory types with importance scores |
| ByteRover | Fuzzy text first, LLM-driven when needed | Pre-compression extraction — saves insights before context compaction discards them |
| Supermemory | Semantic; hybrid/memories/documents modes | Context fencing + multi-container partitioning for multi-tenant use |
| Memori | Structured recall | Tool-aware turn capture + project/session attribution (docs-only) |
Setup Difficulty
| Provider | Difficulty |
|---|---|
| Built-in | Trivial (already configured) |
| Holographic | Trivial — hermes config set memory.provider holographic. No API key, no server, no pip install |
| ByteRover | Easy — install brv CLI (script or npm), no API key for local mode |
| Mem0 / RetainDB / Supermemory | Easy — hermes memory setup + API key in ~/.hermes/.env |
| Honcho (cloud) | Easy — hermes memory setup wizard |
| Hindsight (cloud) | Easy — wizard auto-installs; local = Medium (embedded PostgreSQL + LLM API key) |
| Honcho (self-hosted) | Medium — run your own Honcho instance, set baseUrl |
| OpenViking | Medium — pip install openviking, run openviking-server, set OPENVIKING_ENDPOINT |
Four Architectural Styles
- Document store + FTS (built-in) — cheapest, simplest; single-user/machine; always-on baseline.
- Identity modeling (Honcho, Supermemory) — builds explicit per-peer/profile structures; Honcho goes deepest with per-profile AI peers, observation toggles, and three orthogonal cost knobs (
contextCadence,dialecticCadence,dialecticDepth). - Structured knowledge (Hindsight, OpenViking, ByteRover) — organizes memory as navigable structure: knowledge graph with entity resolution (Hindsight), filesystem hierarchy with tiered token-cheap loading (OpenViking), hierarchical knowledge tree (ByteRover). Best when you want the agent to browse what it knows.
- Extraction + retrieval services (Mem0, RetainDB, Memori) and local algebra (Holographic) — Holographic is the outlier: pure local FTS5 + HRR compositional queries with no embedding model at all.
Recommendations by Use Case
| Situation | Pick |
|---|---|
| Just getting started | Built-in — don’t optimize prematurely |
| Memory pressure, zero new infrastructure | Holographic — one command, no API key, trust-scored facts + contradiction detection |
| Solo dev, wants portable memory | ByteRover — local-first brv tree, pre-compression extraction, travels to other tools |
| Agent should deeply model you (or many users) | Honcho — first-party, dialectic user modeling, per-profile AI peers |
| Explicit knowledge graph + cross-memory synthesis | Hindsight — hindsight_reflect is unique; free local mode |
| Data residency, self-hosted structured knowledge | OpenViking — free AGPL-3.0, viking:// hierarchy, first-class URL/doc ingestion |
| Multi-tenant gateway with work/personal partitioning | Supermemory (multi-container + {identity} tags) or Honcho profiles |
| Hands-off extraction, nothing to curate | Mem0 — server-side LLM extraction with dedup |
| Predictable budget | RetainDB — flat $20/mo, hybrid vector + BM25 + rerank |
| Maximum vendor neutrality | Built-in + hermes sessions export |
Profile Isolation
Each provider handles multi-instance isolation differently: local-path providers (Holographic, ByteRover) inherit $HERMES_HOME separation; config-file providers (Honcho, Mem0, Hindsight, Supermemory) use per-profile credentials; RetainDB auto-derives profile-scoped project names; OpenViking is configured per-profile via .env. See Profiles & Multi-Instance for the full isolation model.
Try It
- Check your current provider:
hermes config get memory.provider - Switch to Holographic (safest first upgrade):
hermes config set memory.provider holographic - Set up a cloud provider:
hermes memory setup→ follow wizard - Before switching:
hermes sessions exportto preserve session history - Check what Hermes remembers:
/memoryin any session - Measure your standing memory tax before switching for cost reasons: check the byte size of your injected
MEMORY.md/USER.mdlayer and multiply by your typical turns per session. One community report put this at ~2,070 tokens per turn — if yours is comparable, that is the number a retrieval-based provider would be replacing. - Change one thing at a time. The audit above is unusable as evidence because turn limits and reasoning-trace storage changed the same day as the memory stack. If you are evaluating a provider swap, hold
agent.max_turnsandshow_reasoningfixed across the before/after window.
Open Questions
- MemPalace is unverified. It is not among the 9 documented external providers, appears in no Hermes docs source ingested here, and its repo, license, and provider-interface compliance are unchecked. Confirm before recommending.
- What is the built-in provider’s real per-turn injection cost? One community measurement (~8,283 bytes / ~2,070 tokens per turn) exists; the official docs sourced here do not state it, and it presumably scales with how much the user has let
MEMORY.mdgrow. - Does any provider swap survive a controlled test? No source in this article — first-party or community — reports a before/after with other settings held constant. Every cost claim so far is confounded.
Related
- Hermes GAPA — the self-improvement loop that writes to memory
- Profiles & Multi-Instance — how profiles isolate memory per agent instance
- Hermes MemoryKit — community 8-layer memory stack built on top of these providers
- Nate Herk 1-Hour Course — notes that stale memory is the #1 cause of weird agent behavior
- agentmemory — alternative memory architecture for coding agents (4-tier, BM25+vector+KG)