What Is Hermes Agent? Nous Research’s Self-Hosted AI Agent

What is Hermes Agent? It is an open-source, self-hosted AI agent from Nous Research that lives on your own machine or server, talks to you through the terminal or chat apps like Telegram and Slack, runs shell commands and tools on your behalf, and keeps a memory of what it learns. Its pitch is in the repository tagline: “The agent that grows with you.” After a complex task it writes a reusable skill, refines that skill the next time, and carries notes about you and your work from one session to the next.

That combination has made it one of the most talked-about agent projects of 2026. This guide explains what Hermes Agent actually does, how its learning loop works, who should run it and who should not, how to install and lock it down with real commands, what it costs, and how it compares with OpenClaw and Claude Code. Every number links to its source. Where we give an opinion, we say so.

What is Hermes Agent, in plain terms

Hermes Agent is a general-purpose agent harness, not a model. You bring a language model (from Anthropic, OpenAI, OpenRouter, a local Ollama server or the Nous Portal subscription), and Hermes supplies everything around it: a chat interface, a tool layer that can run terminal commands and edit files, a scheduler, a messaging gateway, and a persistent store of memories and skills. The code is MIT-licensed on GitHub, so you can run it, modify it and use it commercially without a licence fee.

Nous Research is the lab behind the Hermes family of open-weight models, and the agent shares the brand but not the dependency: you can point it at any supported provider. According to The Next Web’s report on the company’s funding, the agent was released under the MIT licence in February, Nous says it has been cloned more than 24 million times since, and the company raised $90M to build a business edition called “Hermes for Businesses”. That article also cites a Wall Street Journal valuation of $1.5bn, which Nous did not confirm itself.

The short version for a business reader: Hermes is a digital assistant you host yourself, that can act (not just answer), that you reach from the messaging apps your team already uses, and that is designed to get better at your recurring work the more you use it. If you need a refresher on the general idea, our explainer on what an autonomous agent is covers the basics.

How Hermes Agent works: the learning loop

Most chat assistants forget everything when the window closes. Hermes is built around three layers of persistence, and understanding them explains both its strengths and its failure modes.

1. Curated memory

Two small Markdown files sit in ~/.hermes/memories/: MEMORY.md for the agent’s own notes and USER.md for your profile. The memory documentation caps them at 2,200 and 1,375 characters respectively and loads both into the system prompt as a frozen snapshot at the start of each session. They do not auto-compact: when a write would exceed the limit, the agent has to consolidate or delete entries first. The small cap is deliberate. It forces the agent to keep only what is worth paying tokens for on every turn.

2. Session search

Every conversation is stored in ~/.hermes/state.db with SQLite FTS5 full-text search. When the agent needs something from three weeks ago, it searches past messages on demand instead of carrying them in context. The same documentation puts the cost difference plainly: memory costs about 1,300 tokens on every prompt, while session search costs nothing until it is used.

3. Skills it writes itself

After a non-trivial workflow, Hermes can save the procedure as a skill: a folder with a SKILL.md file that follows the Agent Skills open standard. Next time, it loads the skill instead of rediscovering the steps, and patches the skill when it learns a better way. The skills documentation describes progressive disclosure: only names and descriptions load by default, and the full text loads when a task matches. If the idea of skills is new to you, our comparison of hooks, skills and subagents shows the same pattern in Claude Code.

Put together, the loop is: do the task, note what matters about you in memory, save the method as a skill, and retrieve old details by search. For a deeper look at why these layers matter, see our guide to agent memory and context management.

Who Hermes Agent is for, and who should skip it

Hermes is a good fit when three things are true: someone on the team is comfortable in a terminal, the work repeats often enough for skills to pay off, and you want control over where data and credentials live. Typical good fits we see in small and mid-sized businesses:

• Founders and ops leads who live in Telegram or Slack and want to fire off requests (“summarise yesterday’s support tickets”, “check if the invoice run finished”) without opening another app.
• Technical operators running recurring checks: server health, report generation, data pulls, inbox triage on a schedule.
• Agencies that want one harness they can point at different model providers per client, for cost or data-residency reasons.
• Teams with privacy constraints that prefer a local model or a specific cloud region over a vendor-hosted assistant.

It is a poor fit when nobody will own the server, when the job is a fixed integration that a workflow tool like n8n or Make does more predictably, or when you need audited, role-based access across a large organisation today. Hermes is a single-user-first tool: its memory and skills belong to one agent profile, and multi-user governance is what the announced business edition is meant to add. Our view: if the task is the same five steps every time, build a workflow; if the task varies and needs judgment, an agent like Hermes earns its keep.

How to install and set up Hermes Agent step by step

The official quickstart supports Linux, macOS, WSL2 and native Windows. One requirement catches people out: the model must have a context window of at least 64,000 tokens, and smaller models are rejected at startup. Here is the minimal path we recommend, adding one layer at a time.

Step 1: install

# Linux, macOS, WSL2
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
source ~/.bashrc   # or source ~/.zshrc

# Windows PowerShell
iex (irm https://hermes-agent.nousresearch.com/install.ps1)

As with any curl | bash installer, read the script first on a production machine. Better still, install on a dedicated VPS or VM, not your laptop.

Step 2: pick a provider and model

hermes model                    # interactive provider and model picker
hermes setup                    # or the full wizard
hermes config set OPENROUTER_API_KEY sk-or-...

The wizard offers Quick Setup through Nous Portal, Full Setup, and a Blank Slate mode that leaves only the provider, file operations and terminal enabled. We suggest Blank Slate for a first business deployment: fewer tools means fewer surprises. Secrets go to ~/.hermes/.env and settings to ~/.hermes/config.yaml.

Step 3: prove a plain chat works

hermes --tui        # recommended terminal UI
hermes --continue   # confirm sessions persist
hermes doctor       # diagnose problems

Step 4: sandbox the terminal

hermes config set terminal.backend docker

Running commands in a container is the single most useful safety setting (more on that below). Only after these four steps work should you add the messaging gateway, MCP servers, extra skills or voice.

Step 5: add a skill or an MCP server

hermes skills search kubernetes
hermes skills install openai/skills/k8s

MCP servers go in config.yaml under mcp_servers, with the command, arguments and environment for each, which is how Hermes reaches tools like GitHub, a CRM or a database.

Connecting Hermes to Telegram, Slack and email

The feature that makes Hermes feel like a colleague rather than a developer tool is the gateway: one background process that connects the agent to your chat apps. The messaging documentation lists Telegram, Discord, Slack, Google Chat, WhatsApp, Signal, Microsoft Teams, Matrix, email, SMS through Twilio and a long tail of regional platforms.

hermes gateway setup        # interactive wizard for each platform
hermes gateway install      # user service (systemd on Linux, launchd on macOS)
hermes gateway start
hermes gateway status
journalctl --user -u hermes-gateway -f   # logs on Linux
sudo loginctl enable-linger $USER        # keep running after logout

Two settings matter for a business. First, set a home channel with /sethome in the chat you want notifications to land in. Second, decide who may talk to the bot. Access is denied by default, and you grant it with allowlists such as TELEGRAM_ALLOWED_USERS or a cross-platform GATEWAY_ALLOWED_USERS. Never open the bot to everyone: anyone who can message it can ask it to run commands on your server.

A practical tip from our own deployments: chats on messaging platforms can run as one session for weeks, and new memories only reach the prompt at the next session. Type /new at natural breaks, such as the start of each week, so the agent picks up what it learned.

Scheduling unattended work with Hermes cron

Hermes has a built-in scheduler, which is what turns it from a chat assistant into something that works while you sleep. Per the cron documentation, the gateway checks for due jobs every 60 seconds and runs each one in a fresh agent session, then delivers the result to a chat, a channel or a local file.

hermes cron create "weekdays at 8am" "Summarise new support tickets from the last 24h and flag anything urgent" --deliver slack
hermes cron create "every 2h" "Check server status"
hermes cron create "every 5m" --no-agent --script memory-watchdog.sh --deliver telegram --name memory-watchdog
hermes cron list
hermes cron doctor

Schedules accept plain phrases (daily at 7am, every monday 9am), intervals, standard cron expressions and one-off timestamps. Two options are worth knowing. --no-agent --script runs a script without calling the model at all, which costs nothing in tokens and is the right choice for simple threshold checks. And telling the agent to reply with only [SILENT] when everything is fine suppresses the message on healthy runs, while failures still get delivered. That pattern keeps an ops channel quiet until something actually needs a human, which is the difference between a monitor people read and one they mute.

Because every cron run is a fresh session, attach the relevant skill with --skill so the job starts with the procedure instead of rediscovering it.

Security: approvals, allowlists and sandboxes

An agent that can run shell commands is a security decision, not a productivity toggle. Hermes ships several layers, documented in its security guide:

• Dangerous-command approval. Commands are matched against risky patterns such as recursive deletes, DROP TABLE, curl ... | sh and writes to /etc/. The default approvals.mode is smart, where a helper model approves low-risk commands, denies clearly dangerous ones and asks you about the rest. manual asks every time. off disables checks and is meant for throwaway containers only.
• A hardline blocklist. A short list of catastrophic commands, like rm -rf / and fork bombs, is always refused, even in YOLO mode.
• Container isolation. The Docker backend drops all Linux capabilities, sets no-new-privileges and limits processes to 256. Note the trade-off: on container backends Hermes skips the dangerous-command checks because the container is treated as the boundary, so mount only the folders the agent needs.
• Credential protection. Writes to paths like ~/.ssh/ are blocked, MCP subprocesses receive a filtered environment, and private network addresses are blocked by default to prevent server-side request forgery.

Our recommendation for a business deployment: Docker backend, approvals.mode: manual for the first two weeks, a short user allowlist, and skills.write_approval: true so you review every skill the agent writes before it is used. Loosen one setting at a time once you have seen how the agent behaves. Our guide to human-in-the-loop design for agentic AI explains where approvals belong in a workflow.

Hermes Agent vs OpenClaw vs Claude Code

Hermes is usually compared with OpenClaw, the other big open-source personal agent, and with vendor coding agents like Claude Code. They overlap, but they are built for different jobs.

Sources: the Hermes repository and the OpenClaw repository. OpenClaw is the larger project by community size, at roughly 393k GitHub stars against about 258k for Hermes when we checked, and it has a wider set of companion apps for voice, camera and screen actions. Hermes’s differentiator is the learning loop: it is designed to write and refine its own procedures. If you already run OpenClaw, Hermes can import its persona, memories, skills and messaging settings with hermes import-agent openclaw --dry-run first to preview.

Claude Code is the odd one out: it is a coding agent that happens to be scriptable, not a personal assistant. Pick it when the work is in a repository; see our Claude Code vs Codex comparison for that decision.

What Hermes Agent costs: a worked example

Hermes itself is free. You pay for three things: a machine to run it on, model tokens, and any paid tools. There are two common ways to pay for the last two.

Option A: Nous Portal subscription

The Nous Portal bundles model access and a hosted cloud agent. The Plus plan is $20 a month, Super is $100 and Ultra is $200, each with daily, weekly and monthly usage limits. Tools such as web search, scraping and browser use are billed per use against the same credit balance. This is the simplest option and the most predictable for a light, single-user workload.

Option B: your own server and API key

Run Hermes on a small VPS and pay a model provider per token. As a worked example, take a Hetzner cloud server starting at €5.99 a month and Claude Sonnet 5.5 at $2 per million input tokens and $10 per million output tokens. Assume (our assumption, not a benchmark) an ops agent handling 40 tasks per working day, each using about 30,000 input tokens and 2,000 output tokens once memory, skills and tool results are counted.

The levers are obvious once you see the table. Input tokens dominate, so keep the toolset small (every enabled tool adds schema text to every prompt), keep memory tight, and move simple checks to --no-agent scripts that cost nothing. A cheaper model for routine cron jobs and a stronger one for interactive work is a common split. Our breakdown of the cost of running multi-agent systems goes further on token budgeting.

Common Hermes Agent mistakes and how to avoid them

• Installing on your daily laptop with full permissions. The agent can read and write whatever your user can. Use a VPS or VM and the Docker backend, so a bad command damages a container, not your files.
• Turning everything on in the setup wizard. Each tool adds prompt tokens and attack surface. Start from Blank Slate and add tools when a task needs them.
• Trusting skills you did not read. Hub installs are scanned for exfiltration and prompt injection, but scanners miss things. Run hermes skills inspect before installing, and keep skills.write_approval on so the agent’s own edits are reviewed too.
• Assuming memory saved because the agent said so. The memory docs list this first in troubleshooting: check that the entry is actually in MEMORY.md. Models sometimes claim a write they never made.
• Using a small local model. Anything under a 64K context is rejected, and small models that pass the limit still struggle with long tool chains. Test on a strong hosted model first, then try to downsize.
• An open bot. Never set GATEWAY_ALLOW_ALL_USERS=true on a bot that can run commands.
• Noisy cron jobs. A daily “all fine” message trains people to ignore the channel. Use [SILENT] for healthy runs.

A realistic example: a morning ops digest

Here is how a 15-person services company might use Hermes in its first month, built only from documented features. The ops lead installs Hermes on a small VPS with the Docker backend, connects Slack through the gateway, and allowlists three people. They add two MCP servers: one for the helpdesk and one for the accounting tool, each with a read-only API key.

Week one is interactive. The ops lead asks in Slack, “Pull yesterday’s tickets tagged billing and list any customer who wrote twice.” The first attempt takes several back-and-forth corrections. Afterwards Hermes proposes a skill called something like billing-ticket-digest; because write approval is on, the lead reviews the diff with /skills diff and approves it.

Week two, the lead schedules it: hermes cron create "weekdays at 8am" "Run the billing ticket digest; reply [SILENT] if there are no repeat contacts" --skill billing-ticket-digest --deliver slack. Most mornings the channel stays quiet; on days with repeat contacts, a short list arrives before the team starts work. By week four, the skill has been patched twice as the agent learned new ticket tags, and each patch went through the same review.

The point of the example is the shape, not the specific task: interactive first, capture the method as a skill, review it, then schedule it with a quiet-on-success rule. That is the loop Hermes is designed for.

Alternatives to Hermes Agent and when to use them

Hermes is not the only way to get an always-on assistant, and for many businesses it is not the first one to try.

• A workflow tool (n8n, Make, Zapier). Use one when the steps are fixed and you need reliability, audit logs and non-technical maintainers. Add an AI step only where judgment is needed.
• OpenClaw. Use it when you want the larger community, device companion apps and a broader plugin ecosystem, and do not need the self-writing skill loop.
• Claude Code or Codex scheduled tasks. Use them when the recurring work lives in a git repository, such as reports, content or code maintenance.
• A framework like CrewAI or LangGraph. Use one when you are building an agent into your own product rather than running a personal operator. Our guide to single-agent vs multi-agent architecture helps with that choice.

A useful rule of thumb: the more the task changes from run to run, the more an agent like Hermes beats a fixed workflow; the more the task must be identical and auditable every time, the more a workflow tool wins.

Checklist before you let Hermes Agent run alone

1. Installed on a dedicated VPS or VM, not a personal laptop.
2. terminal.backend set to docker, with only the needed folders mounted.
3. A model with at least 64K context; a cheaper model chosen for routine cron jobs.
4. Toolset trimmed to what the jobs need; Blank Slate as the starting point.
5. approvals.mode set to manual for the first two weeks.
6. Messaging allowlist set; GATEWAY_ALLOW_ALL_USERS not used.
7. skills.write_approval: true, and every hub skill inspected before install.
8. Read-only API keys for MCP servers wherever writes are not required.
9. Gateway installed as a service, with lingering enabled and logs checked once.
10. Cron jobs use --skill and reply [SILENT] on healthy runs.
11. A monthly token budget and a calendar reminder to review spend.
12. hermes backup run, and hermes update tested on a copy before production.

FAQ

Is Hermes Agent free?

Yes. The software is MIT-licensed and free to use commercially. You still pay for the model you connect it to, a server if you do not run it locally, and any paid tools. A Nous Portal subscription is optional.

Can Hermes Agent run with a local model?

Yes, through Ollama, LM Studio, llama.cpp or another compatible endpoint, as long as the model has at least a 64K context window. Set the context explicitly, for example -c 65536 in Ollama. Expect weaker tool use from small local models than from frontier hosted ones.

Is Hermes Agent related to the Hermes language models?

Both come from Nous Research, but the agent does not require a Hermes model. It works with dozens of providers, including Anthropic, OpenAI, OpenRouter, Google and DeepSeek, and you switch with hermes model.

Can I move from OpenClaw to Hermes Agent?

Yes. Install the importer plugin with hermes plugins install agent-importers, preview with hermes import-agent openclaw --dry-run, then run the import. API keys only come across if you add --migrate-secrets.

Is Hermes Agent safe for company data?

It can be, if you configure it that way. Self-hosting keeps data on your server, but the model provider still sees prompts unless you run a local model. Use the Docker backend, allowlists, manual approvals and read-only keys, and treat the agent like a new employee with limited access.