2026-09-28 · 5 min

Hermes remembers 2 KB. Put the rest in an Obsidian vault.

Hermes's built-in memory is a tiny budget injected into every turn, so it can never hold anything long. This is the store I put everything else in, and why an Obsidian vault is the right shape for it.

The problem

I kept telling Hermes things. Decisions we'd made, why a thing was built the way it was, the command that finally worked. A week later it would have no idea, and I'd explain it again.

The instinct is to say it's forgetting. It is remembering exactly as much as it was built to.

Hermes keeps its persistent memory in a small set of files that get pasted into the system prompt: the instructions the model reads before your message, on every turn of every session. That is what makes it feel like memory, with no lookup and no search. It is simply there, and that is also the constraint. Because it goes into every single turn, it has a hard character budget. Mine is capped at 2,200 characters, and it told me it was full at 98%.

That design is right, and not something to work around. A 2 KB always-on budget is the correct home for standing facts: who you are, where you work, what you prefer, which conventions apply. It is the wrong home for work product, which means notes, decisions, the shape of a problem, and procedures you worked out once and will need again.

What it needs instead is a second store with better properties. It has to be plain text you can grep, rather than a database that stays opaque at 2am. It has to be read on demand instead of always on, so it costs nothing on unrelated turns. You need to be able to edit it in a normal editor, not only through Hermes. And it needs versioning, because you will want to see what you thought three weeks ago.

Why an Obsidian vault, specifically

A folder of markdown files opened as an Obsidian vault gives you all four. One property makes it work, and it is easy to miss: it is the same files on disk.

Nothing gets exported, and nothing is synced through an API. Hermes writes a file and the note appears in your vault; you edit a note and Hermes reads your edit, because there is only one copy and both of you are pointed at it. Normally your notes live in a notes app and Hermes's context lives somewhere else entirely, and you spend your time shuttling things between them. Here there is one store with two readers.

Then Obsidian adds what a plain folder lacks:

• Wikilinks: [[some-topic]] is a link Hermes can write and you can click, which is how you get a connected set of notes without designing any structure up front.
• Search across everything, instantly, because it is local text.
• Backlinks and the graph view, which show you what points at this note. Useful for spotting connections Hermes made that you hadn't.
• Your own editor, on desktop and phone, offline, with no account.
• No lock-in. If you stop using Obsidian tomorrow the notes are still markdown in a git repo, readable by your editor, by grep, and by the next agent you try.

That last point is why I'd pick a folder of files over a database-backed memory feature. A purpose-built memory service stores facts for recall, which is a different job. This is a work record that happens to be machine-readable.

Setting it up

1. Make it a private git repo

Keep it private, since it will contain your working notes.

gh repo create vault --private --clone
cd vault
mkdir -p daily notes projects

2. The layout, and the one rule

daily/2026-09-28.md      one note per day, appended to
notes/some-topic.md      everything else (FLAT)
projects/<repo>/         one folder per project

Three folders and one rule: nothing nests under notes/. The moment there are subfolders, choosing one becomes a decision, and a decision means it doesn't get written down. A topic that outgrows a single file graduates to its own folder under projects/, and that's the only promotion that exists.

3. Open it as a vault

In Obsidian: Open folder as vault, and pick the clone. That is the entire integration, and it is now your notes app as well as Hermes's store.

Add Obsidian's machine-local state to .gitignore before your first commit:

.obsidian/workspace.json
.obsidian/workspace-mobile.json
.obsidian/cache
.obsidian/plugins/*/data.json

Those change every time you open the app and have no value in history.

If you keep the clone on a second machine as well, pull before you edit and push after, so there is one writer at a time.

4. Point Hermes at it

Hermes lets you set this with an environment variable, so keep the path out of the prompt:

# in Hermes's .env ($HERMES_HOME/.env)
OBSIDIAN_VAULT_PATH=/absolute/path/to/vault

Then give Hermes the conventions as a loadable document, a skill in Hermes's case, rather than as memory. That distinction matters: a document like this loads only when the task is relevant, since Hermes shows the model a title and description and pulls in the body on demand. It can be as long as you like, and it costs nothing on a turn about something else. The file carries the path, the layout, and the rules:

# Vault

Path: /absolute/path/to/vault

daily/YYYY-MM-DD.md      one note per day, appended to, never edited retroactively
projects/<repo-name>/    one folder per project, named after the repo
notes/                   everything else (FLAT), one topic per file, kebab-case

Rules:
- Promote, don't pile up. Durable knowledge moves from a daily note into a project
  page. Project pages are rewritten in place, never appended to as "v2".
- Nothing nests under notes/. A topic that outgrows one file moves to projects/.
- Heavy artifacts stay out. PDFs, builds, screenshots get linked, not committed,
  so the repo clones in a second and never becomes the pile.
- No index file. Search and [[wikilinks]] navigate. A hand-written index is the
  thing that goes stale.
- Anything that documents code lives in that code's own repo under docs/, where it
  versions with the code and gets reviewed. The vault note links to it.

After each working session, append a short entry to today's daily note without
being asked: what changed, what's still open, wikilinks out to durable pages.

5. The rule that makes it work

That last paragraph is the one people skip, and it decides whether the store is worth anything in three months.

Make Hermes write to it unprompted. If the vault only contains what you remembered to write, you have added a folder to your life rather than a memory. If Hermes files its own account of each session, including what is still broken, the record becomes complete enough to be useful for things you never intended, like noticing a mistake you have now made three times.

What it buys you

• One store, two readers. Hermes's account of the work sits beside your own notes, in the app you already read things in.
• A memory you can audit. You get to see what Hermes thinks it learned, and correct it. A memory you cannot inspect is a memory you cannot trust.
• A record you can mine later. Last night Hermes read the last four days of daily notes and proposed three articles from what I'd learned. That is not something you can ask for when the notes are scattered across four tools.
• History for free. When something breaks, the note from the day you built it is usually the fastest way back to what you were thinking.
• Links instead of folders. A [[wikilink]] finds a topic wherever it lives, so you never have to design a taxonomy before you can start writing.

The rule that matters

One home per fact. A thing that documents code lives with the code. A decision lives on the project page. The daily note is where it was noticed, not where it lives.

Get that right and the vault stays small enough to read.