Hermes Agent v0.23.1 calls itself a single-tenant personal agent whose only boundary against an adversarial model is the operating system, and OpenClaw v2026.11.3 says it is not designed as a shared multi-tenant boundary, so neither isolates people from each other on one instance. Both ship a sandbox that covers tool execution only: Hermes's terminal backend leaves code execution, MCP subprocesses, plugins, hooks and skills on the host, and OpenClaw's sandbox, OpenShell backend included, leaves the Gateway process outside. OpenClaw has published 722 GitHub security advisories (14 critical, 249 high, 390 medium, 69 low) with fix versions; Hermes has published none, while the NVD holds 39 low and medium CVE records against it from one third-party CNA, 28 of which say the vendor did not respond. Those numbers measure disclosure regimes, not safety. For a governed rollout to staff, choose OpenClaw, one gateway per person inside a container or VM, with the hardened baseline and openclaw security audit in the build. Choose Hermes only for individual engineers under whole-process wrapping, manual approvals and your own egress policy. Run neither as a shared team service, and start this week by checking managed endpoints for ~/.hermes and ~/.openclaw.
Someone on your team wants Hermes Agent or OpenClaw on their work machine, and you have to say yes, no, or yes with conditions. The usual Hermes Agent vs OpenClaw comparison answers with a feature table: channels, skills, the learning loop. That is the wrong document to decide from. Both projects publish a SECURITY.md, and both say, in their own words, that they are single-operator tools. Hermes Agent v0.23.1 opens its trust model with "Hermes Agent is a single-tenant personal agent" and states that "The only security boundary against an adversarial LLM is the operating system." OpenClaw v2026.11.3 opens with the statement that it "is not designed as a shared multi-tenant boundary between adversarial users on one gateway."
So the question for a bank, an insurer or a hospital is not which agent is safer. Both vendors have already told you neither one protects you from the model or isolates your staff from each other. The question is which one you can wrap, monitor and patch.
The verdict, up front: for a governed rollout to staff, choose OpenClaw, one gateway per person inside a container or VM, because it publishes a fix record your vulnerability management can track and gives you declarative tool-deny config. Allow Hermes for individual engineers only, under whole-process wrapping with your own egress policy, and with a written decision that you accept a vendor with no published advisories. Run neither as a shared team service. Everything below is read from the two projects' policies, docs and release notes at those tags, the GitHub API and the NVD; nothing here was installed or run. For where this sits among other agent architectures, see our AI agents pillar.
Hermes Agent security vs OpenClaw security: what each policy promises
Both policies are candid about their own limits. Read side by side, they describe two personal assistants with heuristics on top and an operating system underneath.
Three rows decide the deployment. First, prompt injection is out of scope in both. A report that the model was talked into running a command will not become an advisory in either project unless it also bypasses a policy, auth or sandbox boundary. Your controls have to assume the model will be talked into things.
Second, approvals are a guardrail in both. Hermes is explicit that "a denylist over shell strings is structurally incomplete." If your risk acceptance rests on a human clicking approve, it rests on a component both vendors describe as accident prevention. Keep approvals, because they catch mistakes, and design where they sit with the guidance in human-in-the-loop approval for AI agents, but do not count them as a control against a hostile input.
Third, neither isolates people. OpenClaw's multi-user docs put it plainly: session ownership, sidebar visibility and presence indicators "are usability features, not security boundaries." Hermes says session identifiers "are routing handles, not authorization boundaries." OpenClaw's company-shared paragraph is the only place either policy blesses a shared agent, and it does so only when everyone using it already shares one trust boundary. In a regulated team, the person handling claims and the person handling HR cases do not.
| Hermes Agent v0.23.1 | OpenClaw v2026.11.3 | |
|---|---|---|
| Tenancy model | "a single-tenant personal agent" | "personal assistant (one trusted operator, potentially many agents), not shared multi-tenant bus" |
| Stated boundary | The operating system; "Nothing inside the agent process constitutes containment" | Host and gateway trust boundaries; recommended mode is one user per machine, one gateway per user |
| Approvals, redaction, scanners | Heuristics: the approval gate "catches cooperative-mode mistakes, not adversarial output" | Exec approvals are "operator guardrails to reduce accidental command execution, not a multi-tenant authorization boundary" |
| Plugin trust | Plugins "run with full agent privileges" | Plugins load in-process and get "the same trust level as local code running on that gateway host" |
| Several people, one instance | "Within the authorized set, all callers are equally trusted" | Cross-operator visibility on one gateway "is expected in this trust model" |
| Company-shared use | No equivalent paragraph; use separate instances with separate allowlists | Valid "when users are in the same trust boundary and the agent is strictly business-only", on a dedicated machine, VM or container |
| Prompt injection | Out of scope: "Prompt injection per se" | Out of scope: "Prompt-injection-only attacks (without a policy/auth/sandbox boundary bypass)" |
| Bug bounty | None | No paid bounty |
| Disclosure channel | GitHub Security Advisories or email, 90-day window | Email or per-repo GitHub Security Advisories |
OpenClaw sandbox vs Hermes terminal backend: what stays on the host
Each project ships a sandbox, and each sandbox covers less than its name suggests.
Hermes's SECURITY.md describes two postures. Terminal-backend isolation runs LLM-emitted shell commands, plus the read_file, write_file and patch tools, inside a container, a remote host or a cloud sandbox. The default backend is local: "The default runs commands directly on the host." The policy then lists what the terminal backend does not confine: "everything the agent does in its own Python process. That includes the code-execution tool (spawned as a host subprocess), MCP subprocesses (spawned from the agent's environment), plugin loading, hook dispatch, and skill loading (all imported into the agent interpreter)." Skills deserve their own sentence, because the policy says "skills execute arbitrary Python at import time."
Whole-process wrapping is the second posture: the entire process tree runs inside a sandbox, either Hermes's own Docker image and Compose setup or NVIDIA OpenShell. The policy calls this "the supported posture" when the agent reads content from surfaces the operator does not control (the open web, inbound email, multi-user channels, untrusted MCP servers) "and for production or shared deployments."
OpenClaw's equivalent is weaker by default. agents.defaults.sandbox.mode defaults to off, and tools.exec.host defaults to auto, which means the sandbox when a sandbox runtime is active and the gateway host otherwise. When the sandbox is on, it covers tool execution (exec, ls, read, write, edit, apply_patch, process) and an optional sandboxed browser. The docs list what is not sandboxed, and the first item is "The Gateway process itself." OpenShell appears in OpenClaw too, but as a tool backend: OpenClaw's docs say the OpenShell gateway "is distinct from the OpenClaw Gateway, which continues to run the agent and host-side plugins." Our earlier NemoClaw and OpenShell analysis covers what OpenShell itself does; the point here is only where the line falls.
Read the table as three columns that matter: the two defaults, where everything runs on the host, and the last, where everything is inside something you control. The two sandbox columns in between protect you from a destructive shell command or file write and little else. OpenClaw's Code Mode makes the same point in miniature: its default node executor uses node:vm in a worker thread that, per the policy, "runs with the Gateway process's OS privileges", and "node:vm is not a security boundary". The bundled QuickJS executor (tools.codeMode.executor "quickjs") is the hardened option. MCP subprocesses on the host are the reason the MCP server hardening checklist applies to both agents unchanged.
There is one contradiction to resolve before you write your standard. Hermes's own guide to securing it on a work machine says "Hermes ships secure-by-default", describes the docker terminal backend with "the container itself is the security boundary", and says that if your requirement is containment, the answer is an isolated terminal backend. SECURITY.md says the opposite about what that backend confines. Side with SECURITY.md. It is the normative document, it is the one a vulnerability report gets triaged against, and it is the stricter of the two.
For a single developer laptop where a container is too heavy, an OS-level profile is the lighter step, covered in sandboxing coding agents without a VM. It is still a step below whole-process wrapping on a managed fleet.
| What runs where | Hermes, local backend (default) | Hermes, terminal backend | OpenClaw, sandbox off (default) | OpenClaw, sandbox on (any backend) | Whole-process wrapper |
|---|---|---|---|---|---|
| Shell commands | Host | Sandbox | Host | Sandbox | Wrapper |
| File tools | Host | Sandbox | Host | Sandbox | Wrapper |
| Code execution | Host | Host | Gateway process (Code Mode on node:vm) | Gateway process (Code Mode on node:vm) | Wrapper |
| MCP servers | Host | Host | Host | Outside the documented sandbox scope | Wrapper |
| Plugins | Host, in-process | Host, in-process | Host, in-process | Host, in-process | Wrapper |
| Skills | Host, imported Python | Host, imported Python | Host | Outside the documented sandbox scope | Wrapper |
| The agent or gateway process | Host | Host | Host | Host | Wrapper |
Hermes Agent CVEs vs OpenClaw advisories: what 722 versus zero tells you
Counted from the GitHub API, OpenClaw has 722 published repository security advisories: 14 critical, 249 high, 390 medium and 69 low. The first was published on January 31, 2026 and the last on September 11, 2026, with none since. By month: 3 in January, 220 in February, 204 in March, 108 in April, 67 in May, 45 in June, none in July or August, and 75 in September. Only 39 of the 722 carry a CVE id in the advisory record. Several criticals are gateway scope escalations, such as GHSA-4jpw-hj22-2xmc, "Pairing-scoped device tokens could mint operator.admin and reach node RCE." Others include a sandbox escape via a TOCTOU race in the remote filesystem bridge (GHSA-9p3r-hh9g-5cmg) and path traversal in plugin installation (GHSA-qrq5-wjgg-rvqw). These are fixed-and-disclosed issues, not open ones. The early-2026 incident history is in our OpenClaw security crisis write-up, and we will not retell it here.
Hermes Agent has published zero repository advisories. That is not the same as zero vulnerabilities. The NVD holds 39 CVE records naming NousResearch hermes-agent, all assigned by one third-party CVE Numbering Authority, published between April 27 and September 3, 2026. Under the CNA's CVSS 4.0 scoring, 23 are low and 16 medium, with no high or critical. Every one sits in NVD status Deferred, and 28 of the 39 descriptions say the vendor was contacted early and did not respond. Five target components Hermes's policy declares heuristics: CVE-2026-9350 and CVE-2026-9367 against the approval gate, CVE-2026-9353 against Skills Guard, and CVE-2026-9366 and CVE-2026-10223 against the context and memory content scanners. A typical record is CVE-2026-14625, a protection mechanism failure in tui_gateway/server.py affecting versions up to 0.15.2, scored 2.1 low.
The two records are not comparable as safety scores, and OpenClaw's own comparison page with Hermes says its counts "are not a safety score." Hermes's policy states that out-of-scope reports "don't go through the private-disclosure channel and don't receive advisories", and its out-of-scope list includes exactly the heuristic bypasses five of those CVEs describe. So the zero partly reflects a policy that sends a whole class of bug to ordinary issues.
Hermes's own documentation adds one more data point. Its Docker docs say an unauthenticated public dashboard "was the entry point for the June 2026 MCP-config persistence campaign", in which internet scanners drove exposed agents into planting an SSH-key backdoor. No advisory was published for it, consistent with a policy that puts public exposure out of scope.
The procurement question that falls out of this is narrow and answerable. Does the vendor publish a machine-readable fix record your vulnerability management can ingest, and does its policy accept the class of bug you care about? OpenClaw answers yes to the first. Hermes answers no, and that, not the raw count, is what moves a governed rollout.
| OpenClaw | Hermes Agent | |
|---|---|---|
| Published repository advisories | 722 (14 critical, 249 high, 390 medium, 69 low) | 0 |
| Who publishes | The vendor, with fix versions | Third-party CNA records in the NVD (39) |
| Severity of the third-party records | Not counted here | 23 low, 16 medium |
| Vendor response noted | Advisories are the response | 28 of 39 say no response |
| What the policy excludes from advisories | Prompt-injection-only chains, public exposure, shared gateways | Heuristic bypasses, prompt injection, chosen postures, public exposure |
Running Hermes Agent or OpenClaw on-prem in a regulated perimeter
The unit of deployment is one wrapped instance per person. Both policies say it; your architecture should enforce it rather than trust a sidebar.
For Hermes, whole-process wrapping is the minimum, and the shipped Compose file needs a correction. At v0.23.1, the repository's docker-compose.yml runs both the gateway and the dashboard with network_mode: host. That wraps the process tree for filesystem and process isolation, with the image running as a non-root hermes user and all mutable state under /opt/data, but it shares the host's network namespace and applies no egress policy. Add your own network policy or use OpenShell's egress controls, which Hermes's SECURITY.md describes as declarative policy across filesystem, network, process and inference layers. On a cluster, the same rule holds, and agent sandboxes on Kubernetes only help if you write the egress policy explicitly.
For OpenClaw, the SECURITY.md Docker guidance is a reasonable start: the official image runs as the non-root node user, and the policy recommends --read-only and --cap-drop=ALL. Its example uses the latest tag; pin a version tag instead so a release does not reach staff before your review. Then apply the documented hardened baseline, which sets gateway.bind to loopback with token auth, restricts the tool profile to messaging, denies the automation, runtime and filesystem tool groups, sets exec to deny with ask always, disables elevated tools and agent-to-agent calls. Put openclaw security audit in the image build: it reports findings with check ids such as gateway.bind_no_auth, --deep checks a live gateway, and --fix narrowly flips open group policies to allowlists and tightens file permissions. Hermes's docs give a starting config rather than an audit command, so the equivalent check is yours to write.
Both projects ship fast enough that change control matters. Between October 1 and November 13, 2026, Hermes shipped 12 stable releases and OpenClaw 22, counting its parallel maintenance lines. Hermes's v0.23.0 notes alone report about 1,950 merged PRs since v0.22.0. A security team cannot review a diff that size per release, so pin, review the release notes and policy diff, and promote on your schedule instead of auto-updating.
Local inference keeps prompts and documents inside the perimeter, and both agents support it. Hermes v0.22.0 added a managed llama.cpp runtime ("no account, no API key") with engines for CPU, CUDA, Metal, Vulkan or ROCm, and it accepts any OpenAI-compatible endpoint through a custom base URL. The one trap: a first Desktop install with no provider gets the hosted nous/welcome trial model, once per OS user; the CLI, TUI and gateway do not. Deploy the CLI or gateway, or configure the internal endpoint before Desktop onboarding. Hermes's docs also state that API calls go only to the provider you configure and that it collects no telemetry; that is the vendor's claim, so confirm it with your own network policy. OpenClaw's llama.cpp plugin runs a hardware check and verifies a real tool call before changing the default model, and it also takes vLLM, SGLang or any OpenAI-compatible server. Its docs warn that local models do not provide hosted providers' safety filters, and its policy adds that weak model tiers are easier to prompt-inject. On a local model, tool restriction matters more, not less. Whether a local model is good enough for the work is a separate decision, covered in local LLM vs Claude for companies.
Hermes Webapp, dashboard and OpenClaw Control UI: what to keep off
Each agent can grow network-facing surfaces beyond the terminal. For regulated data, the default for all of them should be off.
The Hermes Webapp serves the full Desktop workspace "in any browser on your network or behind a public URL with sign-in", and it is single-user: "a signed-in tab acts as you." The v0.23.0 release added a Content-Security-Policy and limited CORS and WebSocket trust to the bound loopback port, which is good hardening for an individual and still a browser session holding your agent. The dashboard change came after the June campaign: HERMES_DASHBOARD_INSECURE is now a deprecated no-op.
OpenClaw's shared-secret bearer path grants more than its name implies. A token on that path grants operator.admin, operator.read, operator.write, operator.approvals and operator.pairing, and scope headers on that path are ignored. A token for an integration is a token for everything. The SECURITY.md language on the Control UI is direct: "It is not hardened for public exposure."
Messaging channels are where untrusted content enters by design. Hermes's policy puts multi-user channels among the surfaces that require whole-process wrapping, and the scope question for skills that channels can trigger is covered in agent skills security scanners. For regulated data, a chat app is not an approved input path.
| Surface | Default | Keep on for regulated data? |
|---|---|---|
| Hermes Webapp (v0.23.0) | Off until webapp.enabled or Web Access is turned on | No |
| Hermes dashboard | Loopback; fails closed on non-loopback binds without an auth provider | Loopback only |
| Hermes messaging gateway | Deny when no allowlist and GATEWAY_ALLOW_ALL_USERS is unset | No |
| OpenClaw Control UI and HTTP endpoints | gateway.bind loopback; "intended for local use only" | Loopback only |
| OpenClaw shared-secret API (/v1/chat/completions, /tools/invoke) | Bearer token grants the full operator scope set | No |
| OpenClaw messaging channels | Per-channel policy; the hardened baseline sets WhatsApp direct messages to pairing | No |
Migrate OpenClaw to Hermes (and back): the import traps
Migration works in both directions, and both directions default toward importing secrets.
From OpenClaw to Hermes, the importer moved out of core in v0.23.0 into the official agent-importers plugin, so the first command is hermes plugins install agent-importers, then hermes import-agent openclaw --dry-run to preview. The guided path is the trap: a fresh hermes setup that finds ~/.openclaw installs the plugin and runs the import with --migrate-secrets, preview and confirmation included. That flag collects provider API keys and bot tokens from the OpenClaw config and environment files and writes them to ~/.hermes/.env. On a managed machine, run the CLI path, omit --migrate-secrets, and provision credentials from your secret store.
The sharper trap is in the mappings. The importer maps an OpenClaw Docker sandbox backend to Hermes terminal.backend docker, and OpenClaw's auto exec approvals to Hermes approvals.mode off. A user who ran tools in a Docker sandbox lands on terminal-backend isolation, which by Hermes's own SECURITY.md leaves code execution, MCP subprocesses, plugins, hooks and skills on the host; and auto approvals become no approvals. Imported skills are copied into ~/.hermes/skills/openclaw-imports/ and, again by policy, execute arbitrary Python at import time. Read them as code before the first session. Cron jobs, plugins and hooks are archived, not migrated, which is the one default here that errs safe.
From Hermes to OpenClaw, v2026.11.3 bundles a Hermes migration provider: openclaw migrate hermes --dry-run previews it, and interactive runs ask whether to import auth credentials with yes selected by default. Pass --no-auth-credentials to import non-secret state only.
Hermes Agent vs OpenClaw verdict: which one, deployed how
OpenClaw wins the governed rollout for two reasons that have nothing to do with features. It publishes a fix record, so your vulnerability management can match an installed version against 722 advisories and their patched versions. And it gives you declarative deny config plus an audit command, so a security standard can be expressed as configuration and checked in a build. Its weaknesses are real: the sandbox is off by default and leaves the Gateway on the host. Both are fixable by your wrapper.
Hermes fits the engineer who wants it and accepts the terms. Its policy is the more precise of the two about what does and does not contain the agent, and its local runtime is a clean path to inference inside the perimeter. Set approvals.mode to manual (the default, smart, uses an auxiliary model to auto-approve commands it judges low risk), wrap the whole process, write the egress policy the shipped Compose lacks, and record that you are running a vendor with no published advisories and 39 third-party CVE records, 28 of which note no vendor response.
The use case matters as much as the tool. These agents earn their place on junior-professional work over a pile of documents that a senior signs off: a first-pass review of a contract set against a clause checklist, or a policy-change impact memo drafted across a folder of procedures. The agent produces the draft and the reviewer owns the decision; it augments the person doing the work. That framing also keeps the agent's tool scope small, which is a control both projects let you set in configuration. In both, review skills and plugins as code, because both policies say they run with the agent's full privileges.
| Scenario | Choice | Conditions |
|---|---|---|
| Governed rollout to non-technical staff | OpenClaw | One gateway per person in a container or VM, hardened baseline, openclaw security audit in the build, GHSA feed in vulnerability management, pinned version |
| Individual engineers on managed laptops | Hermes or OpenClaw | Hermes only under whole-process wrapping with your own egress policy, approvals.mode manual, and a written risk acceptance on disclosure |
| Shared team assistant over regulated documents | Neither on one instance | Separate instances per person, even if the team shares a workflow |
| Internet-facing channel bot with regulated data | Neither | No public channels, Webapp or dashboard on regulated data |
| Hermes Agent v0.23.1 | OpenClaw v2026.11.3 | |
|---|---|---|
| Language, license | Python, MIT | TypeScript, MIT |
| GitHub stars (approx.) | roughly 260,000 | roughly 390,000 |
| Messaging | Telegram, Discord, Slack, WhatsApp, Signal and CLI from one gateway | Messaging channels including WhatsApp, with pairing for direct messages in the hardened baseline |
| Distinctive feature | Closed learning loop with autonomous skill creation | Declarative tool policy and security audit CLI |
| Stable releases, Oct 1 to Nov 13 | 12 | 22 |
What to do this week
Inventory first. Check managed endpoints for ~/.hermes and ~/.openclaw directories, because both agents keep their state there, and an install nobody approved is the one your controls do not cover. Then pick one per the decision table, write the wrapper (container or VM per person, egress policy, pinned version) and subscribe the advisory feed into your vulnerability management before you approve a single install. If the answer is Hermes, add the risk-acceptance note on disclosure now, while the decision is still yours to make rather than one you inherit.
FAQ
Quick answers to the questions this post tends to raise.



