The Hermes Agent control model, explained
Hermes Agent publishes what it refuses to run. The approval patterns are readable source (tools/approval.py), and the security docs describe what the code does. The controls also change quickly: the approval default changed in July 2026, and the hook API is richer than it was in spring. This page is the current reference.
This page covers Hermes’s own controls. For wiring ACP into Hermes, see the install guide. We also published a line-by-line comparison of Hermes’s blocklist against our risk classifier. We adopted five of its categories and credited them.
The approval system
Approvals live under approvals: in ~/.hermes/config.yaml. The trigger is dangerous-command detection: a published pattern list covering recursive deletes, chmod 777, dd, mkfs, destructive SQL, curl | sh, writes to /etc/ and ~/.ssh/, docker daemon redirects, and commands that would kill Hermes’s own gateway. Commands that don’t match run without prompting. Flagged commands go through the mode you set:
smartis the default since July 2026. An auxiliary LLM assesses each flagged command. Low-risk ones are approved, dangerous ones are denied, and uncertain ones go to you. Verdicts are per command, not per category.manualprompts for every flagged command.offremoves the prompting tier. The unconditional protections below still apply.
The prompt offers once / session / always / deny. An unanswered prompt expires to deny after 300 seconds by default, so it fails closed instead of hanging. Always answers are saved to a command_allowlist: in config, where you can read and edit them. Hermes also ships hermes approvals suggest, which reads your approval history and proposes allowlist entries. It never proposes destructive classes. Claude Code’s auto mode does something similar, and we wrote about it in Claude Code’s auto mode.
The move to smart as the default has a cost. A model now decides which flagged commands run, at the point where a person used to decide. That helps with prompt fatigue, but it is judgment, not a rule. For a rule you can count on, write approvals.deny globs. They match against the whole command and are checked before anything else.
The tiers that don’t ask
Two protections sit outside the approval flow:
- The unconditional blocklist (
UNRECOVERABLE_BLOCKLIST) coversrm -rf /, fork bombs,mkfson mounted root, andddonto block devices. It applies in every mode,--yoloincluded. The patterns handle quoted forms likerm -rf "/", and/private/etc/sudoersbecause macOS links/etcinto/private. They also catchgit reset --h, because git accepts unambiguous flag prefixes. - The file-write guard hard-blocks writes to
~/.ssh/keys,~/.aws/,~/.kube/,/etc/sudoers,~/.netrc, project.env*files, and Hermes’s own stores. There is no prompt and no override. This protects Hermes’s own settings from the agent, a category we adopted from this list (and learned about the hard way). An optional write sandbox (HERMES_WRITE_SAFE_ROOT) confines the file tools. It coverswrite_fileandpatch, not the terminal.
The hook surface
Hermes has four extension systems. Two matter for control.
Plugin hooks are Python, run in-process, and register with ctx.register_hook(). pre_tool_call fires before every tool: built-in and plugin tools, terminal, file, web, browser, vision, cron, and custom skills. It can return three directives:
{"action": "block", "message": ...}denies with a reason the model sees.{"action": "approve"}sends the call to the human approval gate. A denial, timeout, or error fails closed.{"action": "modify", "args": ...}rewrites the arguments before execution.
post_tool_call only observes. transform_tool_result can rewrite a tool result before the model reads it, which most harnesses can’t do. Around 40 events exist in total, including observer hooks on the approval flow itself.
Shell hooks (hooks: in config, a matcher regex plus a command) pass JSON over stdin and accept Claude Code-style decisions: {"decision": "block"}, or exit code 2 to block. Two caveats come from Hermes’s own docs. Shell hooks default to fail-open, and fail_closed is a per-hook opt-in. The first-use consent allowlist keys on the command string, not a content hash, so edits to an approved hook script are trusted silently. hermes hooks doctor flags changes in modification time.
Plugins are opt-in (plugins.enabled), and registration takes effect on the next session. If you enable a plugin and nothing happens, restart first. Decline a plugin’s offer to replace built-in tools. Hooks cover every tool without forking them.
Sandboxing
Hermes runs on the host by default. You can point the terminal at an isolated backend with terminal.backend: docker | ssh | singularity | modal | daytona | vercel_sandbox. The docker backend uses hardened flags such as --cap-drop ALL, no-new-privileges, and pids limits. One interaction to know: dangerous-command detection is skipped inside container backends, because the container is the boundary there. Pick one model per environment and know which you picked.
What survives yolo, and the empty chair
--yolo (or mode: off) waives the dangerous-pattern approval tier. The unconditional blocklist, your approvals.deny globs, and the file-write guard all still apply. That is more floor under full-auto than most harnesses keep (what survives yolo mode).
Hermes also defines what happens when nobody is watching:
- A prompt that times out becomes a deny.
- Cron runs use
approvals.cron_mode: denyby default. - One-shot headless queries use
single_query_mode: denyby default.
A flagged command with nobody watching is refused. It isn’t left hanging and it isn’t auto-approved. This is what the empty-chair test asks for. dsh and Gemini CLI’s policy engine are equally clear about it.
Where the native model ends
Hermes gives you a published pattern floor with an unconditional tier, approvals that fail closed with sensible unattended defaults, protection for its own settings, and a plugin hook that can block, escalate, modify, and rewrite. The limits:
- Local and per machine. The config that constrains the agent lives where the agent runs.
command_allowlistandapprovals.denydrift between machines, and nothing reconciles them. - A model in the default loop.
smartverdicts are judgment, not policy. That is fine for fatigue and weak for rules you may need to prove later. - No decision ledger. Approval decisions land in
~/.hermes/state.dband logs. Nothing independent records what was evaluated and why, and nothing leaves the machine. - No identity. The blocklist knows what ran, not who ran it. There is no per-user attribution and no delegation chain when agents spawn agents.
The pairing that works is to keep Hermes’s floor, write guard, and prompt, and add workspace policy, identity, and a record off the machine. Our plugin does that through pre_tool_call. Workspace rules decide. An ask is handed to Hermes’s own approval prompt. In cron or one-shot runs, Hermes’s own cron_mode and single_query_mode: deny refuse it. Every decision lands in a ledger off the machine, which the agent can’t edit.
The plugin fails open. If the gateway or your key is unavailable, the call goes through and the plugin logs the lapse. Hermes has no unattended tier the plugin can key on, so that applies to every run.
Frequently asked questions
How do approvals work in Hermes Agent?
Hermes flags dangerous commands against a published pattern list (tools/approval.py) and routes flagged calls through its approvals mode: smart (the default since July 2026, where an auxiliary LLM auto-approves low-risk calls, auto-denies dangerous ones, and escalates uncertain ones to the human), manual (every flagged call prompts), or off. Prompts offer once / session / always / deny, an unanswered prompt expires to deny after a timeout, and always-approvals persist to a command allowlist in config.
Does Hermes Agent's yolo mode disable its guardrails?
Not all of them. The unconditional blocklist (rm -rf /, fork bombs, mkfs on mounted root, dd onto block devices) holds in every mode including –yolo, and your explicit approvals.deny globs are consulted before yolo is. What yolo waives is the dangerous-pattern approval tier. Separately, the file-write guard’s hard-blocked paths (SSH keys, sudoers, .env files, Hermes’s own stores) have no override at all.
What happens to Hermes approvals when nobody is watching?
They deny. Prompt timeouts expire to deny, cron runs default to approvals.cron_mode: deny, and one-shot headless queries default to single_query_mode: deny. A flagged command in an unattended run is refused instead of left hanging.
Can a plugin intercept and modify Hermes tool calls?
Yes. Plugin hooks fire pre_tool_call on every tool, built-in and plugin tools alike, and can block with a reason, route the call into the human approval gate (denial or timeout fails closed), or modify the arguments before execution. post_tool_call is observer-only, but transform_tool_result can rewrite a tool result before the model reads it. A separate shell-hook system accepts Claude Code-style JSON decisions but defaults to fail-open.
Running Hermes? One command adds a hook. Each tool call it sees is recorded, and a force-push, destructive SQL or curl | sh is blocked until you approve it on the console or from the email.
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
irm https://agenticcontrolplane.com/install.ps1 | iex
What the installer writes · Hermes guide · free up to 5 agents