Hermes: the AI employee that grows with you

Hermes: the AI employee that grows with you

OpenClaw is an agent that can use your computer. Hermes is an AI employee that grows with you. The difference is an automatic self-improvement loop that saves processes as reusable skills.

Hermes Agent https://github.com/NousResearch/hermes-agent is the open-source agent framework from Nous Research https://nousresearch.com/ — a runner-up in the same category as Claude Code and Codex, but one that treats "get better the longer you use it" as a first-class design goal, not a side effect. It runs in your terminal, a native desktop app, messaging platforms (Telegram, Discord, Slack, WhatsApp, Signal, iMessage, Teams, email and more), and IDEs, all from the same agent core. It is provider-agnostic — swap models and providers mid-workflow — and it learns across sessions through two linked mechanisms: persistent memory and reusable skills.

Source: Hermes Agent repo (Nous Research) https://github.com/NousResearch/hermes-agent · Hermes Agent docs https://hermes-agent.nousresearch.com/docs/ · Nous Research https://nousresearch.com/

The self-improvement loop

What makes Hermes feel like an employee rather than a tool is the self-improvement loop running behind every conversation. After a turn, a background review replays the conversation and quietly saves what it learned — a durable fact into memory, or a reusable procedure as a skill. You'll often see a quiet 💾 Memory updated line in chat after it happens.

This review isn't running every single turn; it fires on a counter. Hermes triggers a memory-and-skill review roughly every ~10 turns by default (_memory_nudge_interval = 10, _skill_nudge_interval = 10), each configurable (nudge_interval, creation_nudge_interval). When the counter trips, it spawns a background fork of the agent in its own context that reads the conversation and writes durable lessons back.

Because this is an autonomous write path, Hermes includes a write-approval gate (memory.write_approval / skills.write_approval). Default off — it writes freely — but you can flip it on so every save, especially the unprompted background ones, is staged and reviewed (/memory pending, /skills diff <id>, /skills approve) before it ever enters your profile.

Sources: Hermes docs — Persistent Memory https://hermes-agent.nousresearch.com/docs/user-guide/features/memory · Hermes docs — Skills System https://hermes-agent.nousresearch.com/docs/user-guide/features/skills · (nudge intervals verified in source agent/agent_init.py)

Memory: two files, curated like a real memory

Hermes keeps bounded, curated memory in two files under ~/.hermes/memories/:

File        | Purpose                                                                  | Cap                      
------------------------------------------------------------------------------------------------------------------
`MEMORY.md` | Agent's personal notes — environment facts, conventions, lessons learned | 2,200 chars (~800 tokens)
`USER.md`   | User profile — preferences, communication style, expectations            | 1,375 chars (~500 tokens)

At the start of every session they're rendered into the system prompt as a frozen snapshot — each entry separated by a § delimiter, with a header showing the store and how full it is. The snapshot never changes mid-session (that preserves the prompt cache); new writes persist to disk immediately but surface on the next session. There's no read action — the agent just sees its memory in context.

Memory is curated, not a log:

The practical takeaway: memory is designed to be small and dense, like a professional's notes — not a transcript.

Source: hermes docs — Persistent Memory https://hermes-agent.nousresearch.com/docs/user-guide/features/memory

External memory: Honcho and the provider layer

Built-in files are the default, but Hermes ships with 8 external memory providers — Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, ByteRover, Supermemory — that run alongside built-in memory (never replacing it) and add semantic search, knowledge graphs, and automatic fact extraction. Only one is active at a time.

The standout is Honcho by Plastic Labs https://github.com/plastic-labs/honcho, an AI-native memory backend that does dialectic reasoning: after each conversation turn it analyzes the exchange and derives insights about the user's preferences, goals, and working style, accumulating a deepening model of who you are — beyond what you ever stated explicitly. Where Hermes' built-in memory is manually curated notes, Honcho is automatically reasoned user modeling.

It's architected around two peers — a user peer and an AI peer — both injected into the system prompt, so Hermes knows both who it's talking to and what it knows. Hermes exposes four Honcho tools:

Setup is one command: hermes memory setup, pick "honcho", point at your base URL. The classic test: tell it your favorite language and that you prefer dark mode, start a brand-new session, and ask what it knows about your preferences.

Source: Hermes docs — Honcho Memory https://hermes-agent.nousresearch.com/docs/user-guide/features/honcho · Hermes docs — Memory Providers https://hermes-agent.nousresearch.com/docs/user-guide/features/memory-providers · Honcho + Hermes integration guide https://github.com/plastic-labs/honcho/blob/main/docs/v3/guides/integrations/hermes.mdx

Connect apps with MCP

The second pillar of the "employee" frame is connecting the apps it needs. Hermes has a native MCP https://modelcontextprotocol.io/ (Model Context Protocol) client. MCP is the open standard for connecting AI applications to external systems — an open-source protocol introduced by Anthropic https://www.anthropic.com/news/model-context-protocol — so instead of writing a native Hermes tool for every service, you plug in servers that expose tools.

Configure servers under mcp_servers in ~/.hermes/config.yaml; on startup Hermes connects, auto-discovers each server's tools, and registers them into every platform toolset under a mcp_{server}_{tool} prefix. Two transport types:

A tiny example:

mcp_servers:
  time:
    command: "uvx"
    args: ["mcp-server-time"]

Then just ask Hermes for the current time and it uses mcp_time_get_current_time like any built-in tool. Hermes also ships a curated catalog of Nous-reviewed MCP servers — hermes mcp install n8n — and, for safety, runs stdio MCP subprocesses with a filtered environment (no leaked API keys unless you explicitly pass them), redacts credentials from error messages, and supports MCP's sampling/createMessage capability for agent-in-the-loop workflows.

Source: Hermes docs — MCP https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp · modelcontextprotocol.io https://modelcontextprotocol.io/ · Anthropic announcement https://www.anthropic.com/news/model-context-protocol

Autopilot with cron

The classic "employee" feature: work that runs without you asking. Hermes schedules it with cron, driven through a single cronjob tool, the hermes cron CLI, or /cron in chat — no CLI required.

/cron add "every 2h" "Check server status"
/cron add "every 1h" "Summarize new feed items" --skill blogwatcher

For within-a-session recurring work there's also /loop (timer-driven) and /goal (judge-driven "keep working until done"), but cron is the one that survives restarts and runs unattended — the true autopilot.

Source: Hermes docs — Scheduled Tasks (Cron) https://hermes-agent.nousresearch.com/docs/user-guide/features/cron · Hermes docs — Recurring Loops https://hermes-agent.nousresearch.com/docs/user-guide/features/loops

Skills are the SOPs it writes itself

Skills are procedural memory — on-demand knowledge documents the agent loads only when relevant (progressive disclosure). When the agent works out a non-trivial workflow, hits a dead end and finds the working path, or you correct its approach, it saves the approach via the skill_manage tool (create / patch / edit / delete / write_file / remove_file). This is the "employee grows" engine: it never solves the same problem the same way.

Source: Hermes docs — Skills System https://hermes-agent.nousresearch.com/docs/user-guide/features/skills · Hermes docs — Curator https://hermes-agent.nousresearch.com/docs/user-guide/features/curator

Sub-agents and profiles: a workforce, not just one employee

Hermes scales from one assistant to a small organization:

The personality lives in a file

Where the agent's personality and tone lives matters as much as its tools. In Hermes that's SOUL.md — the agent's primary identity, loaded from HERMES_HOME/SOUL.md (e.g. ~/.hermes/SOUL.md) into slot #1 of the system prompt. Hermes seeds a default one if none exists and never overwrites yours. A file like soul.md keeps the voice consistent across every interaction — the difference between a tool and a colleague.

How to design a good SOUL.md:

Source: Hermes docs — Personality & SOUL.md https://hermes-agent.nousresearch.com/docs/user-guide/features/personality · Hermes docs — Context Files https://hermes-agent.nousresearch.com/docs/user-guide/features/context-files

The five-step recipe, revisited

That turns the recipe into something you can actually build on a schedule, with memory, and with a persona:

  1. Start with an agent — Hermes, in a profile with a SOUL.md identity.
  2. Connect the apps it needs — via MCP servers, the native tools, or the memory providers.
  3. Let the self-improvement loop learn — memory for facts, skills for procedures, ~every 10 turns.
  4. Massage the output until it's good — iterate on the skill until the workflow lands.
  5. Put it on autopilot with cron so it keeps delivering without you asking.

The difference between an agent that can use your computer and an AI employee is that the employee remembers you, learns your working patterns, writes its own runbook, and shows up on schedule. Hermes does all of it — and most of it without being told.

Getting your agent to keep doing something useful without you asking is the single most important idea for building useful workflows.

Sources