All video notes
Video notes · Agent memory

Improved AI Memory? 🧠 Full Hermes Tutorial (Mnemosyne & Hindsight)

Video by Wanderloots on YouTube · 26 min · uploaded August 2026

Notes and analysis by BrainTube, written from the video. Not affiliated with Wanderloots. Watch on YouTube

In short

The video sorts agent memory into three layers (a knowledge layer, built-in memory, and an external memory provider) and then installs two providers for the Hermes agent: Mnemosyne, a local SQLite layer, and Hindsight, a server-backed engine run in Docker with a local GPT-OSS 20B model. The layering is a useful mental model and the install notes save real time. The evaluation is a single 'who am I' recall test, so it cannot tell you which provider actually remembers better.

The argument

Callum's argument is that frustration with forgetful agents comes from treating memory as one thing. He splits it into world knowledge (an Obsidian vault or LLM wiki that holds ground truth across projects), built-in operational memory (files injected into every session), and a dedicated memory provider that stores facts and retrieves them only when a query needs them. Built-in memory is always present but costs tokens on every chat, so for ongoing projects a provider keeps context lean and recall sharper. He then shows two ends of the provider spectrum. Mnemosyne is light, local and needs no LLM. Hindsight needs a server and a model but adds reflection and a browsable memory graph. His advice is to try one for a week and switch if it does not help.

Key ideas, with timestamps

  1. 1:24

    Memory is a stack, not a layer

    He separates knowledge you want organized across everything you do (the Obsidian layer) from facts about how you work and what you are doing now (agent memory). The test he offers is simple and practical: durable knowledge goes in the vault, working preferences and current state go in agent memory.

  2. 3:13

    What Hermes ships with

    Built-in memory is three markdown files: memory.md for operational notes, user.md for who you are, and soul.md for the agent's personality. There is also session search over past chats in a local database. At 4:09 he names the trade-off: the user and memory files are injected into every new session, so the agent never forgets you but pays tokens for it every time.

  3. 5:30

    Layer versus engine

    He picked his two providers from community recommendations, not benchmarks. Mnemosyne is described as zero-dependency, fully local, with built-in embeddings and no LLM required. Hindsight is described as near the top of memory benchmarks but needs either its cloud or your own server plus an LLM. His shorthand: Mnemosyne is a memory layer, Hindsight is a memory engine.

  4. 8:17

    Installing Mnemosyne outside Hermes's environment

    Do not install it into Hermes's managed virtual environment, because a Hermes update rebuilds that environment and wipes extra packages. The docs offer pipx or a manual virtual environment, but neither worked cleanly for him. His fix at 9:14 is to link the new environment into the Hermes plugins folder and run the memory setup command, so Mnemosyne registers as a provider rather than a plain plugin.

  5. 11:05

    Set scope to global and drop legacy memory

    During setup the key choice is the default scope: he switches it from per-session to global, since cross-session recall is the reason to run a provider. At 12:01 he follows Mnemosyne's advice to disable the built-in memory and user profile to avoid duplication and token waste, editing config.yaml rather than running a command to do it.

  6. 13:51

    Working memory, consolidation and triples

    After he introduces himself, the stats show four unconsolidated working memories. Mnemosyne is described as moving working memory into episodic memory over time, following what its docs call the BEAM architecture, and storing structured facts as subject-predicate-object triples, the basic unit of a knowledge graph.

  7. 18:02

    Hindsight on local hardware

    Hindsight cloud has a usage fee, and a hosted model API charges per token on every retain. He instead runs Ollama with GPT-OSS 20B, about 13 GB, and warns that not every local model supports tool calling. At 18:57 he runs the Hindsight server in its own Docker container with restart enabled, one port for the API and one for a dashboard, then points the Hermes profile at it in local external mode.

  8. 21:18

    Retain, recall, reflect

    Retain is slow on a local model and the container logs show the memory engine chunking input. A new session's 'who am I' triggers recall and returns his details. Reflect, shown at 23:06, runs an agentic loop over memory to produce a synthesized read of his goals. He notes that Mnemosyne, as far as he knows, has no equivalent yet.

What it gets right

The three-layer split is the most useful idea here, and it holds beyond Hermes. Many people expect one tool to be both their reference library and their agent's working memory, and then wonder why recall is noisy. Keeping durable knowledge apart from facts about you and your current work makes both easier to maintain.

The token argument is also correct. Anything injected into every session costs context on every turn, so a file of preferences that keeps growing gets more expensive and less focused. Retrieval on demand is the standard answer, and he explains it without jargon.

The install notes are the practical value. Avoiding Hermes's managed environment, linking the plugin folder, setting scope to global, and running the memory server outside the agent's Docker sandbox are the kind of details that cost an evening when the docs skip them. Running Hindsight in its own container with restart enabled is a sensible default.

What it leaves out

  • A real test. Both providers are judged on one question, 'who am I', after one introduction. That shows the plumbing works. It says nothing about recall after weeks of sessions, conflicting facts, or stale preferences. A fair comparison would seed the same twenty facts, update a few, and check what each provider returns a week later.
  • Performance claims are the vendors'. Sub-millisecond queries, built-in embeddings and benchmark rankings are repeated from the projects' own pages. The video does not measure latency or accuracy, and he chose by community buzz.
  • Portability is asserted, not shown. He says most providers let you migrate and there is no lock-in. That may be true for some pairs, but memory formats differ a lot (plain facts, episodes, triples, mental models). Check the export format before you commit months of memories.
  • Privacy of the cloud option. Hindsight cloud stores your memories off your machine, and a hosted model API sees every retain. He picks local for cost, but privacy is the bigger reason for many users.
  • Cost of reflection. Reflect runs an agentic loop with an LLM. On a 20B local model that is slow, and on a paid API it adds per-call cost. The demo also shows an error during reflection that he passes over.

How this applies to memory across AI tools

The video promises that one memory system can serve Claude Code, Codex, Cursor and other agents. That is the right goal. The catch is that each of these providers is wired into Hermes first, and other agents only share it if they connect to the same store. The cleanest shared interface today is MCP. A memory server exposed over MCP can be reached by any client that speaks it, which is the idea covered in persistent AI memory across tools.

The knowledge layer he defers to his next video is the other half. Agent memory knows how you work. The knowledge layer holds what you have read and watched. BrainTube sits in that second layer. It saves YouTube videos with their transcripts, articles, PDFs and podcasts into one compiled knowledge base and exposes it as an MCP server, so Claude, ChatGPT, Cursor and other MCP clients can search it alongside whatever operational memory your agent uses. For the distinction in more depth, see what is an AI memory layer.

Who should watch it

Watch it if you already run Hermes and want a working external memory provider today, or if you want a clear mental model for separating agent memory from a notes vault. The stack explanation is 1:24 to 2:45; the Mnemosyne install and its workaround run from 7:49 to 12:29; the Hindsight local setup with Ollama and Docker runs from 17:06 to 20:49; reflection and the dashboard are at 21:45 to 23:33. Skip it if you want a benchmark comparison of memory providers or you do not use Hermes, since most of the runtime is Hermes-specific configuration.

Frequently asked

What is the difference between Mnemosyne and Hindsight?
In the video, Mnemosyne is a lightweight local memory layer that stores memories in SQLite and needs no LLM to run. Hindsight is a heavier memory engine that runs as a separate server, uses an LLM to retain and reflect, and offers a dashboard with a memory graph. Mnemosyne favors speed and simplicity, Hindsight favors richer recall and synthesis.
Should I disable Hermes built-in memory when using a memory provider?
Mnemosyne's documentation suggests disabling the built-in memory and user profile to avoid duplicate facts and wasted tokens, and the video does so through config.yaml. With Hindsight he turns built-in memory off only for testing. Disable it first, and re-enable it if recall gets worse.
Can I run an agent memory engine fully locally?
Yes. The video runs Hindsight in a Docker container and powers it with GPT-OSS 20B through Ollama, which needs about 13 GB for the model. Pick a local model that supports tool calling, and expect slower retain and reflect steps than with a hosted model.

Keep videos like this one searchable

BrainTube saves YouTube videos with their transcripts into one compiled knowledge base that Claude, ChatGPT, Cursor and other MCP clients can search.

Start free

Go deeper

More video notes

Are you the creator and want this page changed or removed? Contact us and we will act within 48 hours.