Hermes vs OpenClaw: which one to install at home ?

#Hermes vs OpenClaw: the short answer

Both tools belong to the same family: a self-hosted agent under the MIT license, with persistent memory, skills, messaging, scheduled tasks, and support for the MCP protocol. The difference is what each project puts at the center. Hermes Agent, published by Nous Research, presents itself as an autonomous command-line agent whose skills are created and improved through use. OpenClaw, launched by Peter Steinberger, defines itself through its gateway: a process that connects your messaging apps to a model and then executes what the model requests.

Leaning toward Hermes Agent

You work primarily in a terminal, want an agent that accumulates procedures over the course of tasks, and are comfortable with a YAML configuration file and a Python ecosystem.

Leaning toward OpenClaw

You want an assistant available in WhatsApp, Telegram, Discord, Slack, Signal, or iMessage, with a guided installation assistant and a web control interface, in a Node.js ecosystem.

What is equivalent

The license, the Markdown-file memory model, skills in SKILL.md format, integration with Ollama, and the security risks inherent to any agent that executes commands.

What this guide does not do

No numerical ranking, installation time, or speed measurement. We did not compare the two under identical conditions; we compare what their documentation describes.

#Two approaches: the learning agent versus the messaging gateway

Hermes Agent is primarily a terminal agent. Its documentation describes an interactive text interface, more than forty tools (terminal, files, browser, memory, scheduled tasks), a subagent mechanism that delegates tasks, and several ways to run commands: directly on the machine, in a Docker or Singularity container, on a remote machine via SSH, or on a cloud platform such as Modal. The messaging gateway exists, but as an addition: a single process serves the terminal and messaging services with the same memory and history.

OpenClaw reverses the order. Its core is the Gateway, a Node.js process running in the background that keeps connections open with your messaging services, receives every message, passes it to the agent, and sends the response back to the right conversation. By default, it listens only on the machine itself, at 127.0.0.1 and port 18789, and also serves a web control interface. The agent, Markdown file workspace, and skills are organized around this gateway. OpenClaw can take the initiative through scheduled tasks and periodic wake-ups, for example to provide a morning update.

The features eventually converged: both schedule tasks, connect to MCP servers, and load skills. But if you ask each what it does best, Hermes answers “execute and remember,” while OpenClaw answers “be reachable and act.”

Two name mix-ups to avoid. Hermes Agent is not Hermes 4: the former is orchestration software, while the latter is a model family from Nous Research that you may or may not run behind it. OpenClaw was called Clawdbot and then Moltbot until early 2026: earlier tutorials describe the same software using older command names. Our “OpenClaw: what is it?” page traces this history: https://quelllm.fr/guide/openclaw-c-est-quoi

#Memory: Markdown files on both sides, used differently

Both projects made the same choice: memory lives in text files that you can open and edit by hand. The way they fill them differs.

Hermes Agent uses two files for durable memory: MEMORY.md for facts and procedures the agent considers useful, and USER.md for what it remembers about you. They are located in ~/.hermes/memories/. The model decides, through a dedicated tool, what is worth writing there. A human approval option for writes is available, and the documentation acknowledges a weakness: a local model with fewer than about 30 billion parameters may say “noted” without calling the tool. The official advice is to explicitly request that something be remembered, then verify the file.

In OpenClaw, memory is part of the agent's workspace, a folder of Markdown files that also contains its instructions and personality, located by default at ~/.openclaw/workspace. The documentation describes a durable memory file and dated notes there, which the agent rereads at the start of a session and can query. Again, you can open these files in an editor and delete anything that should not remain there.

The fundamental difference lies elsewhere: Hermes relies on self-created skills, discussed below, to retain procedures rather than just facts; OpenClaw retains facts and notes, and relies on installed skills for procedures. The weakness is shared: memory reliability depends on the model, and a small local model may forget to write, write in the wrong place, or confuse your preferences with those of a document it read.

#Skills: learned by the agent or installed from a registry

A skill is a folder containing a SKILL.md file that teaches the agent a specific procedure, sometimes accompanied by scripts. The format is the same on both sides, but the origin of the skills is the clearest difference between the two projects.

Hermes Agent

The documentation highlights skills that are created and improved through use: after a successful task, the agent can write the procedure itself and reuse it later. This is what the phrase “agent that learns” means. You can also write or drop in your own skills.

OpenClaw

Skills are written by hand or installed from ClawHub, the project's public registry. The selection is broad, and that is both its strength and its risk: in early 2026, security researchers reported hundreds of malicious skills on the registry.

Shared risk

A skill contains instructions and sometimes scripts, executed with your permissions. Read a third-party skill in full before enabling it, exactly as you would a downloaded script. Review an agent-generated skill too: it may have learned a bad habit.

#Messaging: OpenClaw casts a wide net, while Hermes covers the essentials

This is OpenClaw’s natural territory. Its documentation lists WhatsApp, Telegram, Discord, Slack, Signal, and iMessage, among others, and the installation assistant offers to connect them from the start. Hermes Agent documents a gateway for Telegram, Discord, Slack, WhatsApp, and Signal. The lists change: check the channels page before choosing it for a specific messaging app.

The operation is identical: the agent opens outbound connections to the service, no inbound port is required, and there is no reason to expose the OpenClaw Gateway or Hermes API to the Internet. Both documentations recommend a dedicated account for the assistant, separate from your personal account.

Controlling who can talk to the agent

OpenClaw: an unknown person who writes receives a pairing code, and the agent ignores their messages until you approve that code. Hermes: a user authorization layer, described in its security documentation, limits which accounts can give it commands.

On-machine interface

OpenClaw serves a control web interface on http://127.0.0.1:18789/, protected by a token. Hermes is primarily controlled through its text interface in the terminal.

#Models: online or local, with the same requirements

Neither provides a model: they call an online provider with your key, or a local model served by Ollama, which listens by default on http://localhost:11434. The tricky part is the same: an agent sends thousands of tokens of instructions and tool definitions before your first message, then waits for tool calls in a strict format.

Hermes Agent is configured in ~/.hermes/config.yaml. OpenAI-compatible servers, including Ollama, vLLM, and llama.cpp, are declared with a base URL and an empty key. One useful detail: roles can target different providers—for example, a local model for the main conversation and another for context compression or session titles. Our dedicated guide explains this integration in detail: https://quelllm.fr/guide/hermes-agent-ollama-guide

OpenClaw declares its providers in ~/.openclaw/openclaw.json, and its documentation requires the native Ollama API—not the OpenAI-compatible interface ending in /v1—or tool calling may be lost. The page that Ollama devotes to OpenClaw recommends at least 64,000 context tokens with a local model. The step-by-step guide: https://quelllm.fr/guide/openclaw-ollama-modeles-locaux

Tool-calling capability

In both cases, choose a model whose Ollama card shows the tools capability. A conventional chat model describes the action instead of executing it.

Model size

Hermes documents unreliable memory below roughly 30 billion parameters. OpenClaw requires a large context. Q4_K_M reference points for weights alone: 14B ≈ 9 GB, 32B ≈ 19 GB, plus the context.

Hardware

A RTX 3060 12GB or a RTX 4070 12GB can handle testing with a 14B model and measured expectations. A RTX 4090 24GB or a Mac M4 Pro with 48 GB of unified memory provides the headroom needed for 32B models with a large context.

Get started online

Both documentations suggest using the most capable model available to you because it is more resistant to malicious instructions. An API key capped by budget is often the best starting point before moving to a local model.

#Installation and maintenance: what the documentation requires

We provide no installation time estimate because we have not measured it. Here is what each project requires according to its documentation; the commands below are intended to measure the effort, not serve as a tutorial.

Hermes Agent: systems

Linux, macOS, and Windows via WSL2. The project is written in Python; the installation script sets up the required environment.

Hermes Agent: method

An official script installs the hermes command. Configuration is then done in ~/.hermes/config.yaml or with the tool’s configuration command, and the messaging gateway runs as a separate process.

OpenClaw: systems

macOS and Linux directly, Windows via WSL2. Node.js is required, at version 22 or later as far as we know; this requirement has already changed, so check it on the installation page.

OpenClaw: method

An npm package or official script installs the openclaw command, then an installation assistant asks questions about the model, messaging services, and security, and registers the Gateway as a service. A Docker Compose installation is also documented: https://quelllm.fr/guide/installer-openclaw-docker

# Hermes Agent (Linux, macOS, WSL2)
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes

# OpenClaw (Node.js requis)
npm install -g openclaw@latest
openclaw onboard --install-daemon

For maintenance, both projects publish updates frequently: Hermes Agent tagged version v0.21.5 on September 24, 2026, and OpenClaw includes an update command, openclaw update, and a diagnostic command, openclaw doctor. An installation left untouched for months becomes a risk because some versions fix vulnerabilities. On a server, pin a version number and read the release notes before updating.

#Security: the same risks, two responses

The danger is the same because it is inherent to the nature of an agent: it reads content from outside sources, accesses private data, and can execute commands. A malicious text may contain instructions that it mistakes for yours, and a small local model is generally easier to hijack than a large one. Our guide to prompt injection explains the mechanism in detail: https://quelllm.fr/guide/injection-de-prompt-llm-local

Hermes Agent documents an eight-layer security model: user authorization, human approval for dangerous commands, safeguards for file writing, container isolation (Docker, Singularity, Modal), filtering credentials passed to MCP servers, prompt-injection detection in context files, isolation between sessions, and work-path validation. Command approval is configured with approvals.mode, with an intelligent default mode that allows low-risk actions and blocks the rest for validation.

OpenClaw documents unknown-user pairing by code, token authentication for the Gateway, running group conversations in an isolated Docker container, and two built-in commands: openclaw doctor for diagnostics, and openclaw security audit --deep to identify dangerous settings. Its recent history shows why these tools matter: the CVE-2026-25253 vulnerability, fixed in late January 2026, made it possible to steal the Gateway token through a malicious link, and researchers documented thousands of gateways accessible from the Internet in early 2026.

Isolation by default

Neither. Hermes executes commands on the machine until you choose a containerized backend. OpenClaw runs on the host and reserves the Docker container for group sessions, unless it is installed entirely in Docker.

Action approval

Hermes: documented at the heart of the product, with three modes. OpenClaw: relies on tool configuration and built-in auditing; the gateway’s security documentation is the page to read.

Attack surface

OpenClaw provides a local web interface and a heavily used skills registry; Hermes provides more tools and backends. In both cases, the fewer channels, tools, and skills you enable, the less you have to defend.

#Hermes or OpenClaw: choose in five questions

Neither is objectively better. The five questions below, asked in order, generally point to a clear favorite. If they split the decision, try both in a virtual machine with a test Telegram bot, using each for one week on the same task without sensitive data: they can be uninstalled without leaving a trace if you isolated them.

1. 01
   Where will you talk to it most often?

   From a terminal, for technical tasks: Hermes Agent is designed for that, with messaging as an add-on. From your phone, in a messaging app you already open ten times a day: OpenClaw is built around this use case, with more supported channels.
2. 02
   What do you want it to remember?

   Procedures it can reuse on its own: Hermes’s bet is that the agent creates skills. Facts, notes, and reminders, with skills you choose: OpenClaw and its Markdown workspace are enough.
3. 03
   Which ecosystem can you troubleshoot?

   When something breaks, you’ll read logs and sometimes code. Hermes is written in Python, OpenClaw in Node.js.
4. 04
   Which model will you connect?

   A capped online provider: either works. A local model on a 12 GB card: expect limitations with both, Hermes on memory and OpenClaw on context. A 32B model on 24 GB or a well-equipped Mac changes the equation for both.
5. 05
   How much maintenance are you willing to accept?

   Both require regular updates and a review of the memory. OpenClaw adds the need to monitor installed skills and gateway exposure; Hermes, execution backends and what the agent learns on its own.

Leaning toward Hermes Agent

Developer or administrator, using the terminal daily, with recurring tasks to automate, looking for an agent that improves and fine-grained control over execution (approvals, isolated backends).

Leaning toward OpenClaw

A personal assistant reachable everywhere, multiple messaging apps including iMessage and WhatsApp, guided installation, a web interface, and a wide selection of ready-to-use skills.

Neither

If the need is limited to chatting with a local model, Ollama with Open WebUI or LM Studio is sufficient with a much smaller attack surface. For an agent confined by design in a container, look at Agent Zero. For automations where every step is decided in advance, n8n with Ollama is more predictable than an agent.

#Official sources to consult

Comparison written on October 13, 2026, based on the official documentation for both projects, reviewed between late September and mid-October 2026, without hands-on testing, measurements, or scoring. Versions, messaging-service lists, and command names change quickly: reread these pages before installing.

https://hermes-agent.nousresearch.com/docs/

https://hermes-agent.nousresearch.com/docs/user-guide/security

https://github.com/NousResearch/hermes-agent

https://docs.openclaw.ai/

https://docs.openclaw.ai/gateway/security

https://github.com/openclaw/openclaw

#Go further

Hermes Agent with Ollama

Exact local provider configuration, models for tool calling, memory, and limits to know. https://quelllm.fr/guide/hermes-agent-ollama-guide

Agent Zero with Ollama in Docker

An agent delivered in a container, with a built-in Linux desktop: isolation is part of its design. https://quelllm.fr/guide/agent-zero-ollama-docker

Goose, the local agent in the terminal

Block's agent connected to Ollama, with its permission modes: another answer to the need for a “terminal agent.” https://quelllm.fr/guide/goose-agent-local

Build a local AI agent: architecture

Model, tools, memory, loop: the building blocks shared by Hermes, OpenClaw, and others, to help you understand what you are installing. https://quelllm.fr/guide/agent-ia-local-architecture