Run it

What the installer puts on disk

A Hermes Agent install on Windows expands to roughly two dozen top-level entries under %LOCALAPPDATA%\hermes. Four of them hold state you cannot regenerate — config, skills, cron, profiles. Everything else is cache, log or download, and deleting it costs you time, not data.

STATE — keepconfig.yaml · 22 sectionsskills/ · 66 entriescron/ · 21 filesprofiles/ · 2REGENERABLE — safecache/ · 18 entriesbootstrap-cache/bin/ · launcherdesktop-plugins/NEVER COPY — secretauth.json · mode 600gateway.lock / .pid*.bak — rollback pointls -1 "$LOCALAPPDATA/hermes" · 80 top-level entries · measured 2026-11-18
Source: our own install, ls + grep -cCounts move with versions; the three classes do not

Most installers lie to you in the same way: they say “done” and leave you with a directory you cannot read. A Hermes Agent install is more honest than most — everything it owns lives under one folder — but the folder has two dozen entries and nothing tells you which ones matter.

This page is a directory-by-directory read of a real install, taken on 2026-11-18, so you can tell state from scratch.

The one command that answers everything

$ ls -1 "$LOCALAPPDATA/hermes"
attachments      config.yaml     gateway-service   profiles
audio_cache      cron            hooks             scripts
auth.json        desktop         _pre_sync_skills  skills
bin              desktop-plugins hermes-agent      ...
bootstrap-cache  gateway.lock    cache             ...

Four of those names are load-bearing: config.yaml, skills, cron, profiles. If you copy only those four to a new machine, you keep your agent’s behaviour. Everything else is either a download, a lock, a log, or a cache.

What each directory actually holds

Entry Holds Safe to delete?
config.yaml every setting: model, terminal, compression, memory, toolsets, approvals No — this is the agent
config.yaml.bak-* timestamped copies written before a config change Yes, after the change is stable
skills/ your procedural memory — 66 top-level entries in this install No — rewriting them is the expensive part
cron/ scheduled jobs (21 files in this install) No, unless you meant to clear the schedule
profiles/ separate agent profiles, each with its own skills and memory No
memory store memory entries, read through the memory tool No — and not editable by hand
cache/ downloads, fetched pages, model metadata (18 entries here) Yes
bootstrap-cache/ first-run download cache Yes
bin/ the launcher the installer put on disk Yes — reinstalled on next update
auth.json credentials, mode 600 No. Never copy it into a repo or a screenshot
*.lock, *.pid gateway and auth locks Yes, with the process stopped

That table is the whole article. The rest of this page is why two rows are traps.

The counts are the least stable thing on this page. The top-level listing reached 80 entries while this page was being written — earlier the same command printed 24. sessions/, logs/, state.db only exist once the agent has actually run, and a single afternoon of use is enough to change the number by 3×. So read the classes, not the totals: four names hold state, four can be regenerated, three must never leave the machine.

Trap 1: the config is a list of sections, not a file of settings

Reading config.yaml as a flat key-value file is the usual mistake. In this install it has 22 top-level sections:

model  terminal  browser  tool_loop_guardrails  compression  prompt_caching
memory  session_reset  group_sessions_per_user  streaming  skills  agent
platform_toolsets  stt  code_execution  delegation  display  updates
plugins  _config_version  auxiliary  voice

Two of them are worth opening on day one. memory decides how much the agent retains between sessions, and platform_toolsets decides what it is allowed to do on this machine. The rest you can leave alone until something is slow or something is denied.

Note the _config_version key. It exists because upgrades migrate your file — which is why hand-editing it in a different shape than the version expects is the most common way to break a working install.

Trap 2: backups are already there, and they are the rollback

The listing shows files like config.yaml.bak_20261116_121538_pre_memlimit2x and config.yaml.bak-deepseek. Those were written by the agent itself before applying a config change, with the change name in the filename.

That means the correct way to experiment is:

  1. change one section,
  2. let the agent write its backup,
  3. restart and observe,
  4. if it regresses, copy the .bak back — no git, no config archaeology.

The backup also tells you something about the install’s history: the two above record a memory-limit change and a provider switch. On a machine you inherited, that filename list is the fastest way to see what was tried.

What you cannot see from here

A directory listing cannot tell you whether memory actually persisted, or whether a scheduled job ran. Those live in the runtime and are read through tools, not ls. If you want to verify a schedule, ask the agent for the job list; if you want to verify memory, ask it to recall something only the last session knew.

We have not tested what happens when auth.json is restored from a different machine — it is plausible that tokens are bound to the original install. Treat it as non-portable until you have tested it.

How you know it worked

Three checks, in increasing order of what they actually prove:

$ grep -cE '^[a-z_]+:' "$LOCALAPPDATA/hermes/config.yaml"    # 22
$ sha256sum "$LOCALAPPDATA/hermes/config.yaml" | cut -c1-16  # 9380b09296f29604
$ ls -1 "$LOCALAPPDATA/hermes" | wc -l                        # 80 (and climbing)
  1. Section count still 22. If you edited one section and the count moved, you created or deleted a top-level key by accident — the YAML is still valid, but the file is no longer the file you think it is.
  2. Hash differs in exactly one place. Record the hash before the edit. A changed hash alone proves nothing; it is useful only when you also know what you meant to touch. If you changed memory.max_tokens, everything up to and after that line should be byte-identical.
  3. Behaviour, not files. Restart, then ask the agent to recall something only the previous session knew, and ask it for the scheduled job list. Files prove the config was written; only this proves it was loaded.

The third one is the only one that catches the most common failure: a config that is valid, saved, and silently ignored because the process was never restarted.

How to undo it

Backups are the rollback, and they are named:

$ ls -1 "$LOCALAPPDATA/hermes"/config.yaml.bak*    # 2 in this install
$ cp "$LOCALAPPDATA/hermes/config.yaml.bak_20261116_121538_pre_memlimit2x" \
     "$LOCALAPPDATA/hermes/config.yaml"
  • Config edits: copy the .bak back, restart. Do not git checkout a config that the app also writes — the app owns the file.
  • Deleted cache/ or bootstrap-cache/: nothing to restore. They are download caches; the next run refills them, and the first run after deletion is slower.
  • auth.json: this is the one action with no undo. Copy it out before touching it, keep the mode at 600 after restoring (chmod 600), and never let it reach a repo, a screenshot or a chat.
  • *.lock / *.pid left behind after a crash: delete them only with the process stopped. Deleting a live lock makes two processes think they own the same store.

There are 16 .bak files in this install. That is not clutter — it is the audit trail of every change that was worth backing up.

Reproduce this on your own machine

$ ls -1 "$LOCALAPPDATA/hermes" | wc -l
$ grep -cE '^[a-z_]+:' "$LOCALAPPDATA/hermes/config.yaml"

If the first number is a third of ours, you are looking at a fresh install that has not yet fetched its skills. If the second number is far from 22, your config file predates a migration — check _config_version before editing anything.

Last checked: 2026-11-18, on Windows 11 with the current release. Counts move between versions; the four load-bearing names do not.

Questions people actually ask

Can I delete the cache folder?

Yes. It holds downloads and model/tool metadata. The next run re-fetches what it needs; the cost is a slower first response, not lost state.

Where is my memory stored?

Not in a folder you can read and edit by hand — memory lives in the agent runtime store under the profile, and is read through the memory tool rather than by editing files.

Why are there config.yaml.bak files?

The agent writes a timestamped backup whenever a config change is applied, so a bad edit can be rolled back without a git history. Treat them as recovery points, not as clutter.

Sources


Last checked: 2026-11-18 · 在本机 Windows 11 的实装目录上执行 ls / 计数;条目数随版本变化,重跑一遍即可复核