The Hermes memory system is the file-based memory layer that lets a Hermes agent remember you between sessions: plain markdown files stored on your own machine — an identity file called soul.md, daily notes, and long-term memory files — which the agent reads into context when a session starts and writes new learnings back to when it ends. That is the entire mechanism, and it is the single biggest reason a Hermes agent feels different from a generic chatbot. A generic assistant starts from zero every time you open it. An agent with working memory starts from everything it has ever learned about you and your business — and that difference compounds daily.
📺 Watch: New Hermes Obsidian Memory Galaxy is INSANE!
🔥 Get the Agent OS as a free bonus: AI Profit Boardroom members get the full Agent OS zip, prompt libraries, daily tutorials and weekly live coaching calls. → Get inside
I run Hermes agents across my own business every day — content, SEO, research, admin — and if you forced me to strip features away one by one, memory is the last thing I would give up. This page is the hub: what the memory system is made of, how the agent actually uses it, why files beat the alternatives, and what changes once it all works. Where a component deserves its own full guide, I will point you to it rather than repeat it.
What the Hermes Memory System Is Made Of
Strip away the mystique and Hermes memory is markdown files on your computer. Human-readable, editable in any text editor, portable as a folder. Three core pieces do the heavy lifting:
- soul.md — the agent's identity and personality file. This is where who your agent is actually lives: how it speaks, what it prioritises, how it behaves when nobody is watching. I have written a full breakdown of soul.md because it deserves one — it is the file that makes an agent feel like yours rather than a stock install.
- Daily notes — the running log. What you worked on today, what was decided, what cropped up. Think of it as the agent's diary of your working life together.
- Long-term memory files — the distilled knowledge. Facts about you, your business, your clients, your preferences and your projects: the things worth keeping once the day-to-day noise has boiled off.
Notice what is not on that list: a proprietary database, a black box, a cloud dependency. You can open any of these files right now and read exactly what your agent believes about your world. If it has misunderstood something, you correct it the way you would correct a typo — open the file, fix the line, save. That transparency sounds mundane until the first time you actually need it.
How Hermes Uses Its Memory Each Session
Memory only matters if the agent genuinely uses it, so here is the loop. At the start of a session, Hermes reads the relevant memory into context — soul.md for identity, plus whichever daily notes and long-term memories bear on the task at hand. During the session it works from that context the way a good employee works from institutional knowledge. When it learns something new — a preference you voiced, a decision you made, a fact about a client — it writes that learning back to memory.
Read in, work, write back. Every session makes the next one smarter. Tell it once that you write in UK English and despise corporate jargon, and that preference is simply there tomorrow. Mention that one client wants reports before Monday meetings, and next month the agent still knows. None of this is glamorous — it is a librarian's habit applied relentlessly — but the compounding is real. A month in, your agent carries context no fresh chat window could match.
If you are staring at a blank install wondering where to begin, my Hermes memory setup guide covers getting the first files in place without overthinking it.
If you want a Hermes agent that genuinely knows your business by this time next week — memory, skills, the lot — I will walk you through my exact setup inside AI Profit Lab → Build your agent's memory with me
📺 Watch: Hermes + Jarvis + Obsidian Memory is INSANE!
Why File-Based Memory Wins
Plenty of tools now advertise memory as a feature living inside someone else's platform. The Hermes approach — ordinary files, on your machine — wins for four reasons, and every one comes down to ownership.
- Readable. Markdown is plain text. You can audit every single thing your agent remembers, which stops being a nicety and becomes essential the moment memory starts steering real business decisions.
- Editable. Wrong fact, stale preference, project that ended months ago? Open the file and fix it. No support ticket, no settings maze.
- Portable and backup-able. Because memory is files, it survives restarts without a wobble and travels with your backups. A Hermes export carries your memory, skills and config in one bundle — new laptop, same agent, nothing lost in the move.
- Nobody can take it away. Memory that lives inside a hosted service exists at that service's pleasure. Files on your own disk are yours, full stop.
That last point is the one people underrate until it bites. Months of accumulated context about your business is a genuine asset — arguably the most valuable thing your agent produces — and with Hermes you hold it, not a vendor.
Memory in Bot Mode: Every Bot Gets Its Own Brain
Once you graduate from a single assistant to bot mode, memory gets more interesting, because every bot in your roster carries its own role, its own model, its own memory and its own skills. Your content bot remembers your voice rules and what worked last quarter. Your research bot remembers which sources you trust. Your ops bot remembers how you like things filed and chased.
Per-bot memory is what makes a roster feel like a team of specialists rather than one overworked generalist in different hats. Each bot compounds expertise in its own lane — the same read-in, write-back loop, multiplied across every role you run — and context stays clean, because the finance bot is not wading through content-calendar trivia to find what it needs.
📺 Watch: Hermes Agent Operating System is INSANE!
The Obsidian Upgrade: The Memory Galaxy
Here is where it gets genuinely fun. You can point Hermes memory at an Obsidian vault, and because Obsidian is itself built on markdown files, the two snap together naturally. Do it and you get what I call the Memory Galaxy — your notes rendered as a visual map that your agents read from and write to. New notes appear, links form between them, and you can quite literally watch your agent's knowledge of your business grow on screen.
My full build — vault structure, what goes where, how I organise it so agents find things fast — lives in my guide to the best memory for a Hermes agent. The short version: it is the setup I actually run, and it is the difference between memory as a log and memory as a map. Wiring details shift as Hermes updates, so check the current Hermes docs for the exact config when you connect the vault.
What a Working Memory System Changes in Practice
The honest pitch is simple: memory is what turns a generic assistant into an agent that knows your business. Without it, the first chunk of every session is you re-explaining context you have explained twenty times before. With it, the agent opens already briefed and starts on the work itself.
I test models constantly on Goldie Bench, my own benchmark, and the pattern I keep seeing is that the biggest quality jumps rarely come from swapping to a shinier model — they come from feeding the model you already have better context. Memory is compounding context. In my experience, an agent that knows your business out-delivers a stronger model meeting you for the first time on most day-to-day work.
Memory also sits at the centre of anything bigger you build. When you build an autonomous AI agent, memory is a load-bearing wall — an agent cannot act independently on your behalf if it forgets who you are every morning. It is the same reason the Agent OS treats shared memory as a pillar alongside mission control and orchestration: pull memory out of that triad and the other two have nothing to stand on.
One caution from experience: memory needs tending. Daily notes pile up, facts go stale, and an agent reading cluttered memory is an agent working from a messy desk. I cover pruning, distilling and organising in my Hermes memory management guide — a few minutes a week keeps the compounding clean instead of noisy.
Quick Reference: Hermes Memory Components
| Component | What it does |
|---|---|
| soul.md | Defines the agent's identity and personality — who it is and how it behaves |
| Daily notes | Running log of each day's work, decisions and context |
| Long-term memory files | Distilled facts about you, your business and your preferences |
| The session loop | Reads relevant memory into context at the start, writes new learnings back at the end |
| Exports and backups | Bundle memory, skills and config so your agent moves machines intact |
| Bot-mode memory | Gives every bot in a roster its own role, model, memory and skills |
| Obsidian vault (Memory Galaxy) | Turns memory into a visual map agents read from and write to |
Hermes Memory FAQs
What is the Hermes memory system?
The Hermes memory system is the collection of plain markdown files — soul.md, daily notes and long-term memory files — that a Hermes agent reads at the start of each session and writes new learnings back to. It is how the agent remembers you, your preferences and your business permanently instead of starting fresh with every chat.
Where is Hermes memory stored?
On your own machine, as human-readable markdown files you can open in any text editor. You can also point memory at an Obsidian vault, which turns your accumulated notes into a visual map your agents work from.
Does Hermes memory survive restarts and new machines?
Yes. Because memory is ordinary files, a restart changes nothing, and moving machines is a restore job rather than a rebuild — a Hermes export carries memory, skills and config together, so the agent arrives knowing everything it knew before.
Can I edit my agent's memory myself?
Yes, and you should. If the agent has recorded something wrongly or a fact has gone stale, open the relevant file and correct it. Direct editability is one of the quiet superpowers of file-based memory — you are never negotiating with a black box.
How does memory work with a bot roster instead of a single agent?
In bot mode every bot has its own memory alongside its own role, model and skills, so specialists stay specialist. Your content bot and your ops bot each accumulate knowledge relevant to their own lane rather than sharing one muddled brain.
Verdict: Memory Is the Moat
Most people compare agents on models and party-trick features. I think memory is the real dividing line. The Hermes memory system — files you can read, edit, back up and genuinely own — is simple enough to understand in an afternoon and powerful enough that its value compounds every day you use it. Set it up properly, tend it lightly, and within weeks you have an agent that knows your business the way a long-serving colleague does. That is not a feature. That is a moat.
If you want an agent that compounds — memory, skills and systems that get sharper every week instead of resetting to zero — join me inside AI Profit Lab and I will show you the full build → Start compounding your agent's memory
