Persistent memory: your Hermes agent’s built-in brain

Give your agent tools and it can act. Give it a knowledge base and it can look things up. But there’s still a gap: every new session, it starts blind. It asks the same questions, forgets your preferences, repeats old mistakes. Persistent memory closes that gap — and it’s the line between a generic chatbot and an assistant that’s genuinely yours.

“Isn’t this something the AI does by itself?”

Mostly yes — and that’s the good news. When you first meet this feature it’s natural to wonder what you’re actually supposed to do with it. The honest answer: almost nothing technical. The agent writes its own memory, stores it in its own files, and loads it automatically at the start of every conversation. You never open a file, run a command, or manage storage. In other words, this is a standard, built-in part of Hermes — it ships switched on, with nothing for you to install or set up.

So your role shrinks to two small, human decisions: knowing what’s worth remembering, and tidying up when something goes out of date. That’s the whole job. Everything below is really just helping you make those two decisions well.

How it works, at a glance

The mechanism is simple once you see it. You mention something durable about yourself or your setup; the agent records it as a short fact; and from then on that fact is present the moment any new session begins — before you’ve even typed anything.

You say…	The agent records…	Every future session…
“Reply to me in Dutch”	a fact about your language preference	starts already knowing it
“Always ask before you publish”	a standing rule you’ve set	applies it without reminding
“I prefer local tools over cloud ones”	a durable preference	leans that way by default

You do the talking; the agent does the remembering. There’s nothing to fetch or load on your side — the memory is simply there from the first message.

Memory is not the same as a knowledge base

Later in the series you’ll give your agent an Obsidian knowledge base. It’s easy to think that is memory, but they do different jobs, and keeping them straight is what makes both useful:

• The knowledge base is a library. A pile of notes the agent looks things up in when a task needs them. Big, detailed, consulted on demand.
• Memory is what the agent just knows. A tiny set of facts about you and your setup that travels into every conversation automatically, without being looked up.

A library you consult; memory you simply carry. A recipe book on the shelf versus knowing you’re allergic to nuts — you don’t look the allergy up, it’s always with you. That’s the difference.

The one constraint: memory is small on purpose

Here’s the part the hype skips: memory is not unlimited. It’s capped at about 2000 characters by default — deliberately. Because memory is loaded into every session, every line you keep is baggage the agent carries on every single turn. A bloated memory quietly taxes every conversation you’ll ever have.

Two thousand characters is only a few short paragraphs. You can raise that limit if you genuinely need more room, but it is worth resisting the urge to do it early.

The discipline is the opposite of what people expect. The goal isn’t to remember as much as possible — it’s to remember the right few things. A lean, current memory beats a full one every time. That single idea drives every decision about what goes in.

Decision one: what’s worth remembering

Memory is for stable facts that stop you repeating yourself. If you’d otherwise have to say it again next week, it belongs. Good candidates:

• The language you want replies in.
• A standing rule — “never deploy without asking first.”
• A lasting preference — favouring local tools, or a certain writing style.
• A quirk of your setup that trips the agent up every single time.

And the things that do not belong, because they’ll be wrong soon:

• Task progress (“ticket #42 is open”) — that’s just session history.
• One-off results (today’s weather, a figure from one report) — stale within a day.
• Anything time-bound — if it expires, it becomes misinformation the agent acts on confidently.

The test that settles almost every case: if it’ll be stale in a week, keep it out of memory.

The one habit worth learning: facts, not orders

This is subtle but it genuinely changes how the agent behaves. When you tell it something to remember, phrase it as a fact about you, not a command:

Write this (a fact)	Not this (an order)
“User prefers concise replies”	“Always reply concisely”
“User works mostly in Dutch”	“Always write in Dutch”

A fact describes a preference the agent can weigh sensibly in context. An order, re-read at the start of every session, hardens into a rigid directive that fires even when it doesn’t fit — and that causes friction. Describe how things are, and let the agent apply judgement. Facts age gracefully; orders don’t.

Decision two: tidy up now and then

Memory isn’t set-and-forget — it lives alongside you, so it needs the occasional prune. And the key thing to know is that you do all of it just by talking to the agent in normal chat. No menu, no settings screen, no commands to memorise. Here’s exactly what you type:

• To make it remember something: just tell it. Type “Remember that I want short answers” or “From now on, always ask me before publishing.” Said once, it holds in every future session — you never explain it again.
• To see what it knows about you: ask it. Type “What do you remember about me?” and it lists back the facts it’s holding. That’s how you check what’s in there — no file to open, you just ask.
• To fix or remove something stale: say so in plain words. Type “Forget that I use Windows, I switched to Mac” or “That’s out of date, drop it.” The agent updates or clears the entry for you.

So the monthly tidy-up is really just this: every so often, ask “What do you remember about me?”, read the list, and say “forget…” for anything that’s gone stale. An out-of-date “fact” is worse than none, because the agent trusts it and acts on it confidently. If you can tell a colleague something, you already know how to manage your agent’s memory — that’s the whole skill.

A light note on privacy

Because your profile is the agent’s picture of you, be a little deliberate about it. Keep genuinely sensitive data out — store preferences and rules, not secrets or credentials. A good standing rule to give the agent is to never echo personal data or keys back in a reply. Treat memory as something that could be read aloud, and keep it accordingly. The deeper work of locking down keys and hardening the setup comes later in the series; this is just the light touch.

Why this matters

Without memory, every session starts from zero — same questions, same mistakes, no learning. With a small, disciplined memory, the agent becomes a colleague that already knows your context, your rules, and your preferences. You stop repeating yourself, and it starts feeling less like a tool and more like yours.

Memory tells the agent what it knows about you. The next step gives it a place to store everything else — detailed knowledge that’s too big for memory but too useful to lose. The next article sets up an Obsidian knowledge base: a searchable external brain your agent reads from and writes to. This article is part of the Agentic AI series.