The agent that kept
forgetting.
I was deep in a Hermes session — building something with real care and focus — when I had to restart. The screen went blank. Everything I'd written was gone. Not archived, not recoverable. Just blank. So I built the lightest possible fix.
The session that reset itself
I'd been working with Hermes with a level of focus I rarely manage to hold — the kind where you're building something paragraph by paragraph, where each new prompt builds on three exchanges before it, where the context is dense and the ideas are actually going somewhere. Then something in the environment forced a restart.
When Hermes came back, the screen was blank. Not just the visible context — the whole thread of thinking, the prompts I'd composed with care, Hermes' responses that I'd been building on. All of it: gone. I couldn't even copy-paste what had been there, because there was nothing left to copy. The session had simply ceased to exist.
This happened more than once. Each time, the only option was to re-apply the same focus, the same framing, the same context-building from scratch — and hope I remembered it accurately. That's not a workflow. That's a memory tax on the person, paid in full every time the agent restarts.
A tool that demands you remember everything it forgets is asking you to do its job for it.
What built-in memory actually misses
Hermes has built-in memory, and it does a lot right. The problem isn't that it lacks memory — it's that the gaps it has are exactly the ones that hurt most in practice.
/reset drops the thread entirely. Session search can surface old exchanges if you know what to look for — but it's manual, it's slow, and it requires you to already know what you're looking for. Context doesn't carry over; you carry it over, by hand.The constraint: fix only what's broken
The obvious temptation when you see a memory gap is to build a memory system. Vector databases. Embedding pipelines. Retrieval layers. A background daemon that watches everything and synthesizes it all into a knowledge graph.
I deliberately didn't build any of that. Over-engineering a problem that has a lightweight solution is its own kind of failure — it creates complexity that outlives the original problem, demands maintenance, and eventually becomes the new thing that breaks.
This skill supplements Hermes' built-in memory. It does not replace it, duplicate it, or compete with it. It lives beside the existing system, fills the three gaps above, and does nothing else. If you opened the source and found something doing more than that, I would consider it a bug.
The whole thing is 26 KB. A handful of Python scripts and Markdown files that live in your Obsidian vault. Zero install friction, zero external dependencies, zero cloud. It works the same whether this domain exists tomorrow or not.
fig. 04Hooks: the agent never notices the memory is happening
The core mechanism is the part I'm most pleased with — not because it's clever, but because it puts the problem in exactly the right place.
Instead of asking Hermes to simultaneously answer your question and remember to save the conversation, the skill uses Hermes' plugin hook system. Hooks are observers that fire automatically at defined points in the agent's lifecycle. They're the same pattern used by production observability and logging systems — fire-and-forget, completely decoupled from the main process, incapable of crashing it.
The agent never divides its attention between answering your question and managing memory. The hooks handle memory. The agent handles the work. The handoff is seamless — and it costs Hermes nothing.
fig. 05Memory you can actually read — and correct
This is the improvement I didn't see coming when I started building, but it turned out to be the most significant one.
Because every captured session is a plain Markdown file in your Obsidian vault, the memory isn't opaque anymore. You can open it. Read it. Edit it. Spot something Hermes recorded inaccurately? Fix it before the nightly compression runs. Want to annotate a decision with context the agent didn't have? Write it in. The memory is a shared document between you and the agent — not a vector store that processes you without your input.
Every other memory system stores things about you. This one stores things with you.
The nightly summary doesn't run on raw prompts alone. It runs on whatever the session file contains after you've had a chance to look at it — which means the compression reflects your judgment, not just the raw transcript. That single design decision turns memory from a passive log into an active collaboration.
Why it's free, and why that matters
A tool built for a community should belong to that community. This skill fixes a gap in Hermes that affects everyone who uses it seriously — and the fix is small enough that there's no reason to put it behind a paywall. The source is fully included, every script is readable, every decision is visible. If you think something is wrong or can be improved, you can open it and change it.
That's the version of this that makes sense a year from now, next to any amount of other work: MIT-licensed, community-maintained, and honest about exactly what it does and doesn't do.