Hermes Mnemosyne Memory — measured token impact

Guide

The same trivial task, run once before installing the Mnemosyne memory provider and once after. Real numbers straight out of Hermes' per-session usage log — plus an honest read on what Mnemosyne actually adds versus the rest of the agent's growing prompt budget.

What you’ll learn

How a cold session’s prompt budget grew once the memory provider “carried context.”
What actually moved the needle: the system prompt, tool schemas, and injected memory.
Why warm (cached) conversations stay cheap per message.

Contents

The test & why it's fair
Before vs after — the raw numbers
Honest attribution: what changed
Why prompt caching matters
Bottom-line cost
The Mnemosyne config that shipped

The test & why it's fair

To isolate the memory provider's effect, we ran the identical trivial prompt — Reply with exactly: OLLAMA_V2 — a 2-message, zero-tool-call answer on the deepseek-v4-flash-0731 model via OpenRouter. Trivial means the task cost is the same on both sides; the only variable is what the agent is told to carry into the turn (the system prompt, skills index, tool schemas, and the injected Mnemosyne memory context).

Before: a session recorded in Hermes' SQLite log on 2026-09-03, before the Mnemosyne provider was installed.
After: the byte-identical prompt run on 2026-10-13 with the provider active, both as an interactive session and as a fresh -z one-shot that reports exact usage.

Same model, same provider, same answer. Everything else is the honest delta.

Before vs after — the raw numbers

Metric	Before (Sep 3, no Mnemosyne)	After (Oct 13, Mnemosyne active)
Input tokens	2,050	34,112
Output tokens	161	7
Cache-read tokens	0	0
Total tokens	2,211	34,119
Estimated cost	$0.00	$0.00055
Messages / tool-calls	2 / 0	2 / 0

Headline: the fresh-session input budget went from 2,050 to 34,112 tokens — a ~16.6× jump in what a cold first turn ships to the model. The task itself was identical.

But read that with care — it is a cold, empty-session number. See prompt caching below for what a warm, continuing conversation actually spends.

Honest attribution: what actually changed

The 2,050 → 34,112 jump is not all Mnemosyne. Between the two runs the whole agent grew. A breakdown of the fresh-session prompt budget after the install:

Fixed prompt component	Size
System prompt (identity / guidance / routing)	35,149 chars ≈ ~9k tokens
Tool schemas (69 tools)	99,274 bytes
Injected memory block (MEMORY.md / USER.md)	2,295 chars
User profile	1,365 chars

Mnemosyne's specific additions sit inside that bucket and are modest on top of the pre-existing memory block: a per-turn Mnemosyne Context injection (recalled facts) plus the provider's own tool schemas. The bulk of the growth from 2026-09 to 2026-10 is the accumulated system prompt, skills index, and tool schemas — not the memory provider alone.

Honest caveat. Comparing a Sep 3 session to an Oct 13 session is a fair "before / after the install" story only if you remember the agent changed in between. If you want Mnemosyne's isolated cost, measure the same prompt in one box with the provider toggled on/off via hermes memory off ↔ hermes config set memory.provider mnemosyne. The ~16.6× is the real-world end-to-end delta, not a pure Mnemosyne number.

Why prompt caching matters

In a continuing conversation the giant system prompt is mostly served from a cache, not re-billed each turn. The interactive "after" run of the same prompt showed roughly this shape:

Run	New input	Cache-read	Output
Cold one-shot (`-z`)	34,112	0	7
Interactive, cached prefix	~39	~33,792	7

So the heavy footprint hits on the first turn of a session; every later turn re-reads the cached prefix cheaply and bills only the new tokens. Real-world cost per message is therefore far below the cold number, which is why the measured cost is still in the sub-cent range.

Bottom-line cost

On deepseek-v4-flash via OpenRouter, the measured cost for the identical trivial task went from $0.00 to $0.00055 per fresh session. Even with memory context and an added provider, a trivial turn stays under a tenth of a cent. For a day of real agent work you pay for the conversation flow, not for the memory block itself — and memory-earned recall usually saves the equivalent cost in re-asking.

Workload shape	Measured/expected cost
Trivial answer, cold session	~$0.00055
Same, warm (cached prefix)	~$0.00001 or less
Typical tool-heavy task (multi-turn)	~$0.001–$0.01

The Mnemosyne config that shipped

Example of the provider block below memory: set via hermes config set memory.mnemosyne.* and validated by hermes mnemosyne stats / hermes doctor:

memory:
  provider: mnemosyne
  mnemosyne:
    auto_sleep: true          # run the consolidation daemon
    sleep_threshold: 60       # consolidate once N unconsolidated working memories accumulate
    reflect:
      disabled_for_cron: false
      max_calls_per_session: 3
    ignore_patterns:          # regex: never store things like these
      - ".*ERROR.*"
    skip_contexts:            # don't auto-save inside these agent contexts
      - cron
      - flush
      - subagent
      - background
      - skill_loop
    sync_roles:
      - user                  # auto-save only user turns by default
    profile_isolation: false  # one shared DB vs a DB per Hermes profile
    default_scope: global
    vector_type: int8         # float32 | int8 | bit

Full step-by-step install (venv-aware, the sudo-HOME trap included) is on the companion page.

Public blog · numbers pulled from Hermes' per-session SQLite usage log and its --usage-file one-shot report · same model/provider both sides · deepseek-v4-flash-0731 via OpenRouter · date 2026-10.