Lesson 6 of 6

Memory and the closed learning loop

How Hermes builds a model of you across sessions, how to inspect and manage that memory, and the Obsidian pattern for unlimited long-term storage.

~8 min to complete

Everything in this course has been building toward this lesson. The install, the personality, the Discord integration, the skills — they're all inputs to the loop. This lesson explains what the loop actually does and how to see it working.

The three memory layers

Hermes stores three kinds of memory, each with a different purpose and capacity.

1. Hot memory (per-session, ~9K characters)

Two plain text files injected into the system prompt at the start of every conversation:

~/.hermes/memories/MEMORY.md — the agent's personal notes. Environment facts, project conventions, tool workarounds, lessons learned from past sessions.
~/.hermes/memories/USER.md — your profile. Name, timezone, communication preferences, skill level, things you hate.

The agent manages these using a built-in memory tool — it can add, replace, and remove entries by substring matching. Entries survive across sessions because they're files, not conversation context.

2. Session search (unlimited, FTS5)

Every CLI and messaging session is stored in SQLite at ~/.hermes/state.db with full-text search. The agent can query past conversations by keyword, with optional LLM summarization of results.

Ask Hermes to use it:

Check what Hermes remembers about you

What do you know about me and my work from our past conversations? Summarise it.

Search a specific past session

Search our past conversations for anything related to the deployment issue we worked on. Summarise what happened and what fixed it.

3. Skills (procedural memory)

Covered in the last lesson, but worth restating here: skills are the third memory layer. They encode how to do things, not just facts. A skill that automates your morning GitHub check is memory that runs.

Inspecting memory

hermes sessions list      # all past sessions with timestamps
hermes sessions browse    # interactive search across sessions

To see what's currently in your hot memory files, just ask:

Ask it to reflect on its skills

Read me back your memory file and user profile. What do you know about me right now?

Or open the files directly — they're plain text:

open ~/.hermes/memories/MEMORY.md
open ~/.hermes/memories/USER.md

Editing and deleting memories

The agent manages its own memory, but you can correct it. To remove something wrong:

Correct a wrong memory

Your memory.md says [wrong thing]. That's outdated. Remove that entry and replace it with [correct thing]. Update the file now.

You can also edit the files directly between sessions with any text editor. The agent reads whatever is in the file at session start — your edits are respected immediately.

For Honcho (the external memory provider used for deeper user modeling):

hermes honcho peer      # inspect the peer card — what Honcho knows about you
hermes honcho status    # connection status and config

Honcho conclusions can be deleted individually using the honcho_conclude tool in chat, with delete_id for PII entries.

The curator loop

hermes curator status

The curator runs in the background and:

Reviews skills you've used and improves ones that have gotten stale
Creates new skills from repeated patterns in your sessions
Versions and archives skills that are no longer relevant

hermes curator run        # trigger a manual review right now
hermes curator pin <skill>   # freeze a skill you don't want auto-updated
hermes checkpoints           # inspect the rollback store

If the curator updates a skill in a way you don't like, hermes checkpoints shows the snapshot history and you can roll back.

The Obsidian pattern (going further)

The built-in MEMORY.md has a 2,200-character limit. For months of accumulated context — decision logs, project notes, a searchable history of everything — the community uses Obsidian as an extended memory vault.

No plugin, no MCP server required. Hermes reads and writes the vault using its built-in filesystem tools. Obsidian is just a viewer for the markdown files.

The architecture is three tiers stacked on top of the built-in memory:

Tier	What it is	Capacity	When it's used
1 — Hot	MEMORY.md / USER.md	~9K chars	Every turn
2 — Vault files	context.md, preferences.md, environment.md	Unlimited	On demand, when deeper context is needed
3 — Daily notes	Daily/YYYY-MM-DD.md	Unlimited	Searchable timeline of everything

When hot memory hits ~67% capacity, the agent promotes stable facts to the vault files and keeps the hot tier lean.

To set it up, tell Hermes where your Obsidian vault lives:

Set up the Obsidian memory vault

I want to set up an Obsidian vault as my long-term memory backbone. My vault is at /PATH/TO/YOUR/VAULT.

Please:

Scaffold the directory structure: Daily/, System/Assistant/ (with context.md, preferences.md, environment.md), Work/, Personal/, People/, Inbox/
Update your SOUL.md to include vault access rules: create daily notes at Daily/YYYY-MM-DD.md, route stable facts to System/Assistant/ files when your memory hits 67%, log operational events to the daily note
Create today's daily note with the standard format (Tasks, Schedule, Log, Wins, Context sections)

Obsidian + Honcho coexist fine. Keep them separated by role: Obsidian = human-readable long-term knowledge base. Honcho = AI-managed runtime memory layer. Don't store the same facts in both or you'll get drift. For most beginners, Obsidian alone is plenty.

Community thread with the full copy-paste starter template: reddit.com/r/hermesagent/comments/1stz6gd

The loop in practice

Here's what the closed learning loop looks like after a month of use:

You do work with Hermes
  → It logs what happened to the daily note
  → Repeated patterns become skills (curator)
  → Stable facts migrate from MEMORY.md to vault files
  → FTS5 search lets it recall specific past sessions
  → The next conversation starts with all of that loaded

The longer you run it, the more precisely it reflects your actual workflows. A Hermes you've been running for a month knows your patterns better than one you set up yesterday.

You've finished the course. You have Hermes installed, personalised, connected to Discord, extended with skills and MCP, and now understand how the memory loop compounds over time. The next step is to let it run — the value accumulates in the background.

What comes next

A few directions worth exploring on your own:

Cron jobs — hermes cron create for scheduled autonomous tasks. Morning briefings, nightly GitHub backups, weekly summaries. Tell it in plain English: "every weekday at 7am, check my Todoist and send me a briefing on Telegram."
Multiple profiles — spin up a separate Hermes for work vs personal, each with its own keys, memory, and personality
VPS deployment — if you're still running locally, Lesson 4 explains the rationale. Hostinger's one-click install makes it a 10-minute job
/goal mode — set a standing goal and let Hermes execute across turns without supervision. Useful for overnight research or multi-file coding tasks