A Hermes memory budget is really a token budget: every piece of memory your agent loads rides along in its context, the agent re-reads that context on every step of a run, so remembering is billed over and over rather than once — and the fix is lean recall, cheap brains for routine work, and caching to make the repeated reads close to free.
📺 Watch: How to Reduce Claude Code AI Tokens by 80% (FREE)
🔥 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
Memory is where my agent costs quietly crept up, and it's where I clawed them back. This page is the economics chapter of my Hermes memory system series: what remembering actually costs, why the cost repeats, and the levers I pull to keep my agents sharp without paying a fortune for the privilege.
Why Memory Costs Tokens Again and Again
The mechanic that catches most people out is the re-read. An agent doesn't glance at its memory once at the start of a job and move on. It works in steps — think, act, read the result, think again — and on every step, the whole context goes back through the model. Whatever memory you loaded at the start rides along on every one of those steps.
That's why bloated memory is a recurring tax rather than a one-off cost. An oversized memory file doesn't overcharge you once; it overcharges you on every step of every run, for as long as you leave it in place. Trimming memory is one of the rare optimisations that keeps paying you back after you've made it.
Keep this separate from the hard ceiling, too. How much context a model can hold at all is covered in my Hermes memory limit guide; this page is about the running bill you pay long before you hit that wall. And the same mechanic drives coding agents, which is why my guide to reducing Claude Code token usage reads like a sibling of this one — same disease, same medicine.
Caching: The Counterweight That Makes Memory Affordable
Now the good news. Providers price cached reads far below fresh input, because serving context the model has already processed is cheap for them. That pricing gap is the biggest single counterweight to the memory tax.
The gap is enormous. DeepSeek V4's cache reads work out around 276 times cheaper than Claude Fable 5's fresh input, per DeepSeek's published pricing. And the discount genuinely lands in practice: OpenRouter showed a cache-hit rate of roughly 92 per cent for V4 Pro, meaning the overwhelming majority of repeated context reads were billed at the cheap rate. I've broken the full economics down on my Hermes agent DeepSeek page.
The catch: caching only rewards stability. Memory that sits still — an identity file you wrote once and rarely touch — caches beautifully, and gets read at the discounted rate run after run. Memory that churns — rewritten, reordered or freshly timestamped on every run — keeps missing the cache and paying the fresh-input price. Stable memory is cheap memory; twitchy memory is expensive memory of exactly the same size.
Quick pause: inside my free community I share the memory templates, model-routing setup and cost checklists I use on my own agents, and you can ask me questions directly. Join AI Profit Lab here — then come back for the levers.
📺 Watch: Hermes + Jarvis + Obsidian Memory is INSANE!
The Five Levers of a Hermes Memory Budget
Everything I do to control the bill comes down to five moves. None of them makes the agent know less — they make it carry less.
Lever one: keep the always-loaded core lean
The core is the memory loaded on every run without exception, so it should hold exactly two things: who the agent is, and the evergreen facts of the business that matter in every conversation. Identity, role, offers, standards. Every line in the core is a line you pay to re-read on every step of every run, so every line has to earn its seat.
Lever two: let everything else live in pull-on-demand files
Anything situational goes into topic files the agent pulls only when the job calls for them. Client notes load when that client comes up; campaign detail loads when the campaign is actually being worked on. The budget effect is immediate: memory you don't load costs nothing on the runs that don't need it — and for most files, that's most runs.
Lever three: teach skills instead of re-reading sources
When knowledge lives in a large source document, the expensive habit is re-feeding that document every time a question comes up. The cheap alternative is to have the agent learn it once — distil the source into a compact skill — and answer from the skill from then on. My book-to-skill project's own testing measured 24 to 51 times fewer tokens answering from a learned book than re-feeding the book itself. I walk through that build on my Hermes agent PDF reader page. Learn once, recall cheaply forever.
Lever four: give memory-heavy routine ticks to cheap brains
Not every run deserves a frontier model. Scheduled, routine work — checking feeds, updating logs, ticking through checklists — still drags the full memory load through context on every step, which makes it exactly the place for cheaper models. I route ticks like these to inexpensive options such as DeepSeek Flash, and where a small local model is up to the job, running it through Ollama costs nothing per token at all — my Hermes agent Ollama local guide covers that setup. Save the frontier models for work that's genuinely hard.
Lever five: dedupe, because duplicate facts mean paying twice
Every duplicated fact in memory is a fact you pay to re-read twice per step, indefinitely. Stale entries are worse: when a correction gets written without the old version being removed, you're paying for the wrong answer and the right one. Regular pruning — duplicates merged, corrections applied properly — shrinks the tax directly, and my Hermes memory management guide covers the routine I use to keep files clean.
📺 Watch: New Hermes Obsidian Memory Galaxy is INSANE!
Budgeting for Loops and Bot Rosters
Whatever memory costs you on one run, loops multiply it. A scheduled agent ticking away through the day reloads its memory on every tick and re-reads it on every step of every tick — so a wasteful memory load on a loop isn't one wasteful load, it's a wasteful load hundreds of times over. When I audit a Hermes memory budget, the looping agents get checked first, because a small trim there compounds harder than a big trim anywhere else.
Rosters multiply it again. Run Hermes in bot mode and you've got several named agents, each carrying its own memory — so you're not budgeting one memory, you're budgeting several at once. A roster of lean cores is perfectly affordable; a roster of bloated ones multiplies every mistake on this page by the size of the team.
My Working Memory Setup in Practice
Inside my Agent OS, the memory side follows the levers above. The always-loaded core carries identity and evergreen business facts and nothing else. Topic files hold everything situational and load on demand. Learned skills stand in for the documents they were built from. Routine ticks run on cheap models, and the expensive models are saved for strategy, writing and judgement calls.
My Goldie Bench testing keeps reinforcing the routing half of this: routine, well-scoped jobs simply don't need the priciest model on the menu. Pair a cheap brain with lean, stable memory and the everyday work gets done properly for a fraction of the spend — which frees the frontier-model budget for the jobs that actually stretch it.
Memory Budget Levers at a Glance
| Budget lever | What you change | Effect on the token bill |
|---|---|---|
| Lean core | Only identity and evergreen facts always load | Shrinks the tax charged on every step of every run |
| Pull-on-demand files | Situational memory loads only when relevant | Costs nothing on the runs that don't need it |
| Skills over re-reading | Learn a source once, answer from the skill | 24 to 51 times fewer tokens in my book-to-skill project's testing |
| Cheap brains on ticks | Route routine loops to DeepSeek Flash or local models | Same memory, far cheaper reads; local reads cost nothing per token |
| Dedupe and corrections | Merge duplicates, remove superseded facts | Stops you paying twice for the same knowledge |
| Stable files for caching | Stop churning memory that rarely changes | Repeated reads bill at cached rates, not fresh-input rates |
Hermes Memory Budget FAQs
Does Hermes memory actually cost money?
Indirectly, yes. Memory is loaded into context, context is billed as input tokens, and the agent re-reads context on every step of a run. On paid models that's real spend, scaling with how much you load and how long the run lasts. On local models the per-token price disappears, but the space memory occupies still matters.
How big should the always-loaded core be?
I won't hand you a magic number, because the honest answer is a principle: the core should be small enough that you're happy paying to re-read every line of it on every step of every run — because that is exactly what happens. If a line doesn't justify itself at that frequency, it belongs in a pull-on-demand file, not the core.
Does caching fix memory bloat?
It softens it substantially, but it doesn't fix it. Cached reads are priced far below fresh input, and stable files hit the cache constantly — yet cached is not free, churned files miss the discount entirely, and no pricing helps once you're pressing against the context ceiling. Caching rewards tidy memory; it doesn't excuse bloated memory.
Do local models make the budget irrelevant?
They remove the per-token bill, which is a genuine win for routine loops. But the budget was never only about money: an overloaded context still slows every step, still buries the details that matter, and still runs into the window limit eventually. Lean memory keeps paying off even when the tokens themselves are free.
The Verdict on Spending for Memory
Treat your Hermes memory budget the way you'd treat any recurring bill, because that's what it is — charged on every step of every run. Keep the always-loaded core lean, file the situational material for on-demand recall, teach skills instead of re-reading sources, hand routine ticks to cheap brains, and keep files stable enough that the cache absorbs the repetition. Remembering well and remembering cheaply turn out to be the same discipline.
Want my exact setup? The memory files, routing rules and cost checklists behind everything on this page are inside my free community, along with a crowd of people running the same builds. Join AI Profit Lab here.
