OpenClaw vs Hermes Agent Memory: Side by Side

8 min read

OpenClaw vs Hermes Agent memory compared: file layout, size limits, search, consolidation, external providers and migration, from each project's docs (Oct 2026).

OpenClaw vs Hermes Agent memory comes down to two philosophies. Hermes keeps memory tiny and fixed: two hard-capped files loaded as a frozen snapshot, plus full-text search over old sessions. OpenClaw keeps memory open-ended: Markdown files and daily notes, indexed for hybrid search, with a background job that promotes the best notes into MEMORY.md.

Both are open-source (MIT) agents that run on your machine and chat through messaging apps; Hermes also has an official desktop app that shares the CLI’s memory. OpenClaw comes from Peter Steinberger and the OpenClaw Foundation; Hermes Agent comes from Nous Research. Facts below come from each project’s docs, checked October 2026.

What is the difference between OpenClaw and Hermes memory?

Both agents store memory as plain text the agent writes itself. Hermes bounds it hard, about 1,300 tokens always in context, and treats everything else as searchable history. OpenClaw lets memory grow as files, loads only the curated ones at start, and retrieves the rest by semantic and keyword search.

Neither is “better.” Hermes’s approach keeps prompts small and the prompt cache stable. OpenClaw’s approach holds more and retrieves it, at the cost of an embedding provider and an index. Both sit at the simple end of the spectrum described in AI agent memory explained.

Side-by-side comparison

Hermes AgentOpenClawHindsight (plugin for either)
Always-loaded filesMEMORY.md (agent notes), USER.md (profile)MEMORY.md (durable facts), USER.md (optional profile)None; a memory bank on a server, recalled per query
Location~/.hermes/memories/Agent workspace, default ~/.openclaw/workspaceHindsight Cloud, your own server, or a local embedded daemon
Size limits2,200 and 1,375 characters, enforced by the toolBootstrap budget; over it, the injected copy is truncatedNo fixed cap; recall trimmed to a max_tokens budget you set
Mid-session updatesSaved to disk; prompt updates next session (frozen snapshot)Files on disk; search sees new notes once indexedretain stores facts; later recalls see them
Daily or episodic notesNone; full sessions in SQLitememory/YYYY-MM-DD.md daily notesExperiences and world facts, with time and entities
Searchsession_search: SQLite FTS5 over past sessionsmemory_search: hybrid vector + BM25, recency decay, MMRSemantic + BM25 + graph + temporal in parallel, fused, reranked
Embeddings neededNoOptional (default OpenAI; local GGUF possible)Yes, handled by the server
Write toolmemory tool: add, replace, removeAgent writes Markdown files; memory_get readsretain: an LLM extracts facts, time, entities, relationships
ConsolidationAgent must consolidate when full; background reviewDreaming job promotes notes into MEMORY.md; flush before compactionBackground consolidation into observations and mental models
Write approvalmemory.write_approval: true stages writesDreaming output goes to DREAMS.md for reviewNot listed
Safety scanEntries scanned for injection, exfiltration, invisible UnicodeUntrusted candidates excluded from promotionNot listed
External providersOne at a time: Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, ByteRover, Supermemory, MemoriBuiltin, Honcho, LanceDB engines; Memory Wiki; third-party plugins (Mem0, Hindsight)It is the provider: hermes plugins install hindsight or @vectorize-io/hindsight-openclaw

How Hermes handles memory

Hermes keeps the always-on part small. The agent adds, replaces or removes short entries through a memory tool, and a write that would overflow returns an error so the agent has to consolidate first. The Hermes docs explain the frozen snapshot: it “preserves the LLM’s prefix cache,” so the system prompt doesn’t change mid-session and cached tokens stay cheap.

Anything bigger goes to session history. Every CLI and messaging session lands in ~/.hermes/state.db, and session_search finds raw messages with full-text search. No embeddings, no extraction model. Skills carry procedures the agent learned, as SKILL.md files it writes and patches itself; Hermes Agent skills covers how they’re created, loaded and pruned. The full breakdown is on Hermes Agent memory.

How OpenClaw handles memory

OpenClaw writes more and retrieves more. Daily notes capture running context. MEMORY.md and USER.md load at start. Everything is indexed in SQLite, and memory_search merges vector similarity with BM25, multiplies by a 30-day half-life recency decay and an importance score, and drops near-duplicates with MMR.

Two background steps keep it tidy: a memory flush before compaction asks the agent to save what matters, and dreaming promotes short-term notes that pass score, frequency and diversity checks into MEMORY.md. The full breakdown is on OpenClaw AI agent memory.

Which one remembers better?

There’s no published head-to-head benchmark of the two built-in systems, so any claim that one “remembers better” is opinion. What the designs predict:

  • Exact recent facts in the prompt: about even. Both load a curated file at start.
  • Something said three weeks ago, worded differently: OpenClaw has the edge, since vector search matches meaning and Hermes’s FTS5 matches words.
  • Exact identifiers and error strings: both do fine; FTS5 and BM25 both match exact tokens.
  • Token cost per turn: Hermes is lower and more predictable, by design.
  • Seeing a fact you added mid-session: Hermes shows it in tool responses right away, but not in the system prompt until /new.

If you outgrow either, both accept an external provider. Picking one is the same decision as picking any memory layer; the LLM memory comparison covers Mem0, Honcho, Hindsight, Supermemory and others, and Honcho LLM memory covers what changed in its 3.4 release.

Where Hindsight fits

Both built-in systems stay simple on purpose. When an agent runs for months and its history no longer fits a 2,200-character file or a pile of daily notes, an external provider takes over. Hindsight is one of them, and it plugs into both: it’s in the Hermes plugin catalog (hermes plugins install hindsight), and its OpenClaw plugin can run a local embedded daemon that reuses the LLM you already pay for.

What it adds over the built-ins:

  • Long histories. It reports LongMemEval 94.6 and BEAM 10M 64.1, against Mem0’s 48.6 on BEAM 10M by Mem0’s own comparison page. Scores are vendor-reported.
  • Consolidation that keeps evidence. Related facts merge into observations with quotes and a proof count, instead of an agent rewriting MEMORY.md by hand.
  • Four searches, not one. Recall runs semantic, keyword, graph and time-range search together, so “what did I say about the deploy last week” works without exact wording.
  • Open and local. MIT license, every feature in the open-source server, 25+ LLM providers including Ollama.

Same tools in both agents (Hindsight v1.2.0)

Since Hindsight v1.2.0 (November 3, 2026), the OpenClaw plugin offers the same three memory tools the Hermes plugin has, with the same names and parameters (#5965). So a bank can move between the two agents without changing how the agent is prompted to use it. What each plugin does now:

Hermes pluginOpenClaw plugin
Agent toolshindsight_retain, hindsight_recall, hindsight_reflectThe same three, plus seven knowledge-base tools (browse, search, read, create and edit pages; delete only with allowKnowledgeDelete: true) (#6004)
Tools vs automatic recallmemory_modememoryMode: hybrid (default: auto-recall and tools), context (auto-recall only), tools (tools only)
Background runsCron runs, kanban workers and delegate_task sub-agents are not saved to the bank (#6000)Cron, heartbeat and sub-agent sessions skipped by default; skipOperationalSessions: false lets them use memory, and session patterns can make them read-only (#5963)
When a save failsAutomatic saves are kept and re-sent, up to 5 tries, without storing twice; held in memory, so a crash while the server is down still loses them (#6013)No such change in the v1.2.0 notes

The limit that matters here: it costs more tokens than Hermes’s fixed ~1,300. Each retain calls an LLM, and recall returns more context than Mem0 does by default (about 4x, by Mem0’s measurement), so set max_tokens low if prompt cost matters. More in Hindsight explained.

Migrating between them

The two projects make switching easy:

  1. OpenClaw to Hermes: since Hermes v0.22.5 (October 22, 2026) the importer is a plugin, not part of core. Run hermes plugins install agent-importers, then hermes import-agent openclaw (the old hermes claw migrate still works once the plugin is in). On a fresh install, hermes setup finds ~/.openclaw, asks “Import your setup from OpenClaw?” and installs the plugin for you. It always shows a preview first; --dry-run stops there.
  2. Hermes to OpenClaw: in the OpenClaw Control UI, open Settings → Import Memory. It copies Hermes’s MEMORY.md and USER.md into memory/imports/hermes/, searchable but not merged into OpenClaw’s own MEMORY.md.

What the OpenClaw import does with memory, per the Hermes migration guide:

OpenClawGoes to in HermesHow
workspace/MEMORY.md~/.hermes/memories/MEMORY.mdSplit into entries, merged with what’s there, duplicates dropped
workspace/USER.md~/.hermes/memories/USER.mdSame merge
workspace/memory/*.md daily notes~/.hermes/memories/MEMORY.mdAll daily files merged into the main memory
workspace/SOUL.md~/.hermes/SOUL.mdCopied as is
Skills (4 places)~/.hermes/skills/openclaw-imports/Name clashes skipped by default
API keys~/.hermes/.envOnly with --migrate-secrets

Before it writes anything, it saves a zip of ~/.hermes/ under ~/.hermes/backups/ (turn this off with --no-backup), so a bad import can be undone with hermes import.

After a move, review what came across. A 2,200-character Hermes store maps cleanly into OpenClaw. The other way is the problem: all your daily notes land in one MEMORY.md, and Hermes caps that file at 2,200 characters. Trim them into a few lasting entries, or move the long history into an external provider instead (see where Hindsight fits).

The same plugin also imports from Claude Code, Codex CLI and Cursor. Their instruction files (CLAUDE.md, AGENTS.md, Cursor rules) and Codex’s memories/*.md become Hermes memory entries, and hermes import-agent --sync pulls in later changes.

How to choose

Choose Hermes if you want memory you can read in a minute, predictable token use, and a strong built-in skill system. Choose OpenClaw if you want the agent to keep a growing journal and find old notes by meaning, and you’re fine running an embedding provider (or a local model). In both, memory is guidance, not enforcement; OpenClaw’s docs say so outright. For hard rules, use each agent’s approval and sandbox settings. If either one forgets too much over months of use, add Hindsight as the provider rather than switching agents. And because both agents read content from chats and the web into memory, read up on memory injection attacks before giving either access to untrusted inputs.