Give your Hermes agent a memory that stays

Two weeks ago I noticed something mildly embarrassing: the AI agents I use every day do not remember anything from yesterday. Not because they got slow, and not because they are dumb. The system has no memory between sessions, so every new session starts from zero.

I have written before about moving a Hermes profile between machines. Profiles turn out to be half the problem. A profile stores configuration. What still disappears is the work itself: decisions, preferences, project facts, the reason we picked X over Y. Every new session, all of that has to be explained again.

The setup I run now pairs Hermes with Uteke, an open source local memory engine. This post documents the whole setup from zero, plus what changed after weeks of daily use.

What Uteke is

One Rust binary. No API key, no cloud, no configuration. Data lives in a local folder (~/.codecora/uteke/), search is hybrid (vector plus keyword), and recall runs in around 45ms because everything happens on your own machine. It is Apache-2.0 licensed and at version 0.18.1 right now.

On accuracy: the benchmark numbers are documented in the open, R@5 of 0.98 on the fast50 suite. If you are the type who does not trust vendor claims (the right instinct), the reproduction scripts ship with the repo so you can test it on your own machine.

Setup: about 10 minutes

1. Install

curl -sSL codecora.dev/uteke/install | sh

There are also Homebrew, cargo, and Docker options if piping a script into your shell is not your thing. All of them are fine.

2. Try the CLI first

Before touching any agent, check that the memory behaves like memory:

uteke remember "Deploy v2.1 to staging on Wednesday at 3"
uteke recall "when is our deploy scheduled?"

Notice the second question shares no words with the stored one. The search works by meaning, not keyword matching. That is what separates this from keeping notes in a text file.

3. Connect it to Hermes

There are two integration modes, and the choice shapes how your agent behaves:

MCP, the on-demand mode. Hermes gets access to 46 memory tools (uteke_remember, uteke_recall, and friends), and the agent decides when to store or fetch:

hermes mcp add uteke --command uteke-mcp

Auto-recall. Uteke installs a pre_llm_call hook, so relevant memory gets injected into every LLM call without the agent asking:

uteke init --agent hermes

My advice: install both. Auto-recall for context that should always be there, MCP for explicit operations like creating rooms, searching across agents, or managing old memories.

4. More than one agent? Use rooms

If you run several agents, run Uteke in server mode (one Docker container) and share memory per room. Agents with different jobs can share context through the same room, or stay split for focus.

In my own fleet the numbers look like this: 180 active rooms, and the busiest one holds 60 Hermes agents that work daily. They inherit project context from each other without me copying anything between sessions.

What changed after real use

The most visible change: my agents now know things that could not exist in any prompt. Architecture decisions from a discussion two weeks ago. The reason a certain content idea got rejected. A formatting preference I corrected once and never repeated.

The surprising part is the data. From our internal usage audit: 84% of stored memories are plain facts, not big decisions or deep insights. The stuff that gets stored and recalled most is small and boring. Deploy times, file names, naming conventions. And the average memory is only 449 characters. Small, and constantly useful.

One honest note: about a third of everything ever written is now outdated and superseded. That sounds bad until you look closer. Decisions change, and memory that follows the change is more useful than an archive that refuses to.

What to know before you start

MCP is tool-based. Your agent decides when to call, the system does not force context into every turn (unless you enable auto-recall above). Data stays local, it works offline, and API cost is zero because embeddings also run on your machine.

A cloud version of Uteke is being built and the waitlist is open at cloud.uteke.app. The local version is not a demo waiting for a paid tier. It is fully working today, and for many people local only is enough.

If you want to start: the repo is on GitHub, and the MCP integration docs are in docs/mcp.md. Start with one memory today. Tomorrow your agent still remembers.