Hermes Agent Persistent Memory

What persistent memory actually means

Most AI assistants start fresh every time you open a new conversation. They don't remember that you prefer concise answers, that your project uses pytest with specific flags, or that your 1Password CLI lives at a non-standard path. You end up repeating the same context over and over.

Hermes Agent solves this with persistent memory: a durable, local knowledge store that the agent writes to and reads from automatically. Every time you correct the agent, share a preference, or teach it something about your environment, it saves that fact. On your next session — whether that's five minutes or five weeks later — the agent already knows.

It's not a chatbot history. It's a curated, structured set of facts that the agent actively uses to make better decisions. Think of it as the agent's own notebook — one that gets more useful with every entry.

How it works

Persistent memory is built into Hermes Agent's core toolset. The agent calls the memory tool to save, update, or remove entries, and every entry is injected into the agent's system prompt at the start of each turn. Here's the lifecycle:

1. Discovery. The agent notices something worth remembering — a correction you made, a tool quirk it discovered, a project convention you mentioned.
2. Storage. The agent writes the fact to one of two memory stores: user (who you are, your preferences, communication style) or memory (environment facts, project conventions, tool quirks, lessons learned).
3. Injection. On every future turn, all saved entries are injected into the agent's context. The agent reads them before responding, so it always knows what you've taught it.
4. Self-correction. When you tell the agent something new that contradicts an old entry, it updates the entry. Memory stays accurate because it's maintained by the agent itself.

Two memory stores, two purposes

Hermes Agent splits memory into two stores so it can treat different kinds of facts differently:

What real memory entries look like

Here are actual examples of memory entries, drawn from a real Hermes Agent setup. These entries live in a local SQLite database and are injected into every session:

User is interested in using Hermes for local macOS app automation,
including Apple Notes, and in connecting Google Workspace so Hermes
can access Gmail/Calendar/Drive-style workflows.

User prefers Hermes model-routing configs that preserve ChatGPT/OpenAI
subscription quota by moving auxiliary/background tasks to
cheaper/faster models when practical.

User prefers multi-question requirement gathering in small batches of
about 5 questions at a time, because long question lists are hard to
follow in the terminal.

1Password CLI is installed for the user at ~/.local/bin/op
(version 2.34.0), extracted from the official universal macOS pkg
because Homebrew is not installed.

Google Workspace OAuth is configured for the user via Hermes at
~/.hermes/google_token.json and ~/.hermes/google_client_secret.json.
Use the Hermes venv Python for google-workspace scripts because
macOS system python3 is 3.9 and fails on Python 3.10+ type syntax.

User's Obsidian vault is at ~/Documents/Obsidian Vault, configured
for Hermes via OBSIDIAN_VAULT_PATH in ~/.hermes/.env.

These entries mean the agent never asks "where is 1Password installed?" or "which Python should I use for Google Workspace?" It already knows. When the user says "write a note in Obsidian," the agent reads the vault path from memory and proceeds without a single clarifying question.

How these entries shape behaviour

Because memory is injected before every turn, the agent's behaviour shifts without the user ever having to repeat instructions:

• Coding style. "User prefers pytest with xdist for parallel test runs." → The agent runs pytest -n auto instead of plain pytest.
• Tool paths. "Claude Code CLI is at ~/.local/bin/claude but needs claude auth login." → The agent knows the binary location and that auth is pending.
• Secret handling. "User prefers secure secret handling via 1Password/CLI references rather than pasting passwords." → The agent uses op read references instead of asking for API keys.
• Communication. "User prefers concise responses." → The agent skips the preamble and gets straight to the answer.
• Ongoing correction. The agent tried using macOS system Python for Google scripts and it broke. It saved: "Use the Hermes venv Python." → Never makes that mistake again.

What makes Hermes persistent memory different

Several things set Hermes Agent's memory apart from typical AI chat memory or vector-based context retrieval:

Memory, skills, and cron jobs: three kinds of agent memory

Hermes Agent has three complementary memory systems that work together:

Together, these three systems mean the agent knows what you like (memory), how to do things (skills), and when to act (cron jobs). It's the difference between a helpful chatbot and a genuine AI assistant.

Privacy: where your memory lives

Practical example: a session with and without memory

Here's what the same task looks like with and without persistent memory:

When to use memory vs. when to use skills

A common question: "Should this be a memory entry or a skill?" Here's the rule of thumb:

• Memory is for facts the agent should know: "The project uses pytest with xdist," "1Password CLI is at ~/.local/bin/op," "User prefers concise responses." Memory is declarative — it describes the state of things.
• Skills are for procedures the agent should follow: "How to deploy the site," "How to run the test suite," "How to set up a new Google Workspace OAuth connection." Skills are imperative — they describe how to do things.

If you find yourself writing a memory entry that starts with "Always do X" or "When Y happens, do Z," that's a skill, not a memory entry. Memory says what is true; skills say what to do.

Getting started with persistent memory

Persistent memory works automatically — you don't need to configure anything. The agent starts remembering from your first session. Here's how to make the most of it:

1. Correct the agent when it gets something wrong. Every correction becomes a memory entry that prevents the same mistake in the future.
2. Tell the agent your preferences upfront. "I prefer short answers," "Use 1Password for secrets," "My timezone is Eastern." The agent saves these immediately.
3. Let the agent discover your environment. When it finds your Obsidian vault, your Python path, or your GitHub setup, it saves those facts. You don't need to document everything manually.
4. Review memory periodically. You can inspect memory entries any time. Remove stale ones, and the agent will learn the new state on its own.

Frequently asked questions

Can I see what the agent has remembered?

Yes. Memory entries are stored in a human-readable SQLite database at ~/.hermes/memory.db. You can inspect them directly, or ask the agent: "What do you remember about me?" It will list every entry.

Does memory work across different devices?

Memory is local by default. If you run Hermes Agent on two different machines, each has its own memory store. For multi-device setups, you can sync the memory database file using your preferred sync tool, or use the self-hosted setup with a shared volume.

What happens if the agent remembers something wrong?

Correct it. Say "No, that's not right — the Python path is actually X." The agent updates the entry. Memory is self-correcting because the agent treats your corrections as higher-priority than its own previous observations.

Is memory shared with model providers?

Memory entries are injected into the prompt when you talk to the agent, so the content of those entries is visible to the model provider during that conversation turn. However, the memory database itself never leaves your machine. For maximum privacy, combine persistent memory with a self-hosted model where no data leaves your infrastructure at all.

How is this different from ChatGPT's memory?

ChatGPT's memory is cloud-hosted, managed by OpenAI, and tied to your account. Hermes Agent's memory is local, under your control, and works with any model provider you choose. It also integrates with skills and cron jobs in ways that ChatGPT's memory doesn't — it's part of a broader agent architecture, not a standalone feature.

Can I delete everything and start fresh?

Yes. Remove or rename ~/.hermes/memory.db and the agent starts with a blank slate. No cloud account to delete, no retention policy to wait out.

Next steps

Persistent memory is one of the features that makes Hermes Agent a self-improving assistant. To get the full picture:

• Install Hermes Agent and start building your own memory: Installation guide
• Learn about skills — procedural memory that teaches the agent how to do things: Hermes Agent Skills
• Set up scheduled workflows with cron jobs so the agent runs tasks automatically: Hermes Agent Cron Jobs
• Understand the product with the full overview: What is Hermes Agent?