Skip to content
NewCybercrime Report 2026 · Eight Chapters · A Post Is Not An Incident → Explore The ChaptersCybercrime Report 2026 → Explore
All full reports
Full reportAI agent exposureMonograph 16 / 1920 min read

Unattended AI Agents Exposed: Hermes Kanban Boards, Cron Jobs and Leaked Keys

How 87 open Hermes Agent servers leak task boards, schedules, retry dumps and co-hosted TLS keys

By
Odin by Brandefense
Published
19 November 2026
Reading time
20 min read
Edition
Version 1.1 · TLP:CLEAR
Scope
Prepared November 2026

1. Executive Summary

In short

In a two-week observation window ending 18 November 2026, Odin by Brandefense reviewed 87 servers exposing Hermes Agent folders over open HTTP. On 47 of them (54.0%), the files show unattended automation: schedules, task boards, skill curators and upgrade snapshots. Retry dumps keep full API requests with bearer headers. One US server also exposed TLS private keys for two web panels. Bind file servers on agent hosts to loopback, keep certificate keys out of home folders, and purge dumps and snapshots when you rotate keys.

Hermes Agent is an open-source AI agent from Nous Research. It keeps its state in a hidden ~/.hermes folder. Unlike a chat assistant, it can run as a background service. It schedules recurring jobs, splits projects into task cards for worker agents, and tidies its own skill library without a human prompt. This report looks at what that folder reveals when a server shares it over plain HTTP.

All 87 servers are exposed systems, not attacker infrastructure. Their owners are users who left a directory listing open. Every address, domain, path name and secret value in this report is withheld.

1

Over half of exposed Hermes servers run unattended automation, not chats.

On 47 of 87 hosts (54.0%), the exposed files belong to background subsystems. Skill Curators appear on 41 hosts, code language servers on 7, upgrade snapshots on 6, schedulers on 5 and task boards on 4. One German server exposes all eight subsystems in 14,914 files.

2

Retry dumps and upgrade snapshots keep old credentials after rotation.

When the model provider returns a temporary error, Hermes writes the whole failed request to disk. That file holds the bearer header, the agent's persona and memory, and 31 tool definitions. Upgrade snapshots and .env backups keep older keys next to the live ones.

3

One open file server exposed agent state and web-panel TLS keys together.

On a US virtual server, a Python file server started in /root exposed 7,643 Hermes files and 2,222 scheduler files. The same listing exposed 277 acme.sh certificate files, including ECDSA private keys for two co-hosted web-panel domains.

Three Decisions for Leaders

  1. Treat unattended agents as privileged service accounts. Any agent that runs scheduled jobs, task queues or email skills needs registration, an outbound allowlist and short-lived, scoped tokens.
  2. Ban open file servers on hosts that hold agent state or keys. Ad-hoc Python or Node listeners in /root or /home expose every hidden folder beside them, including snapshots, dumps and certificate keys.
  3. Triage by what is exposed, not by the folder name. A host that shows only bundled skill documents is noise. A host that shows task databases, schedules, retry dumps or private keys needs action.

The Study in Numbers

NumberWhat it is
87Distinct exposed hosts behind the 1,100 directory entries analysed, holding 235,644 indexed files
47 (54.0%)Hosts exposing background subsystems: schedulers, task boards, Curators, language servers or snapshots
14,914Indexed files on one German server that exposes all eight subsystems
277Certificate files exposed next to 7,643 Hermes files on one US server, including two TLS private keys
68 to 42Skills the agent itself merged and archived in one 591-second Curator run
11Verified secret findings: private keys, bot tokens, API keys and endpoint strings

How to use this report.

Security leaders can read Chapter 1 and Chapter 7. Platform and cloud teams should read Chapters 2 to 5. SOC and detection engineers should start with Chapters 6, 8 and 9.

2. What a Hermes Daemon Leaves on Disk

In short

A Hermes install stores scheduler jobs, task boards, curator runs, logs and snapshots under one folder. When a high-port HTTP listener serves that folder, all of it becomes readable.

From chat transcripts to background services

An earlier Odin report looked at exposed .claude, .codex and .cursor folders. Those mostly held interactive coding sessions. The .hermes folders in this study look different. They belong to an agent built to keep working when nobody is typing.

Odin by Brandefense analysed 1,100 open .hermes directory entries. They sit on 87 distinct IPv4 hosts, which together list 235,644 indexed files.

Nine path families

Of the 1,100 entries, 859 (78.1%) map to a named subsystem. The other 241 (21.9%) are root credential files (.env, auth.json, config.yaml), named bot profiles, runtime routers and paste buffers.

SubsystemPath under ~/.hermesEntriesShare of 1,100Hosts (of 87)What it does
Skills libraryskills/, skills/.archive/49945.4%68 (78.2%)Playbooks such as kanban-worker, cron-pipelines and himalaya, plus bundled docs
Daemon logslogs/19017.3%57 (65.5%)agent.log, gateway.log and tui_gateway_crash.log
Memory Curatorlogs/curator/12411.3%41 (47.1%)Unattended skill merging and pruning (run.json, REPORT.md)
Kanban boardskanban/, kanban.db141.3%4 (4.6%)SQLite task queues, project boards and t_<id> worker folders
State snapshotsstate-snapshots/111.0%6 (6.9%)*-pre-update/ copies of .env and config.yaml
Language serverlsp/80.7%7 (8.0%)Headless Language Server Protocol runtime for code navigation
Durable memorymemories/, SOUL.md60.5%2 (2.3%)MEMORY.md and USER.md, injected into every prompt
Cron schedulercron/40.4%5 (5.7%)jobs.json, executions.db, .tick.lock and cron/output/<job_id>/
Session dumpssessions/30.3%4 (4.6%)request_dump_*.json retry payloads and .jsonl transcripts

Top-level counts understate how deep some folders go. This likely explains why the Cron and session rows show more hosts than entries. On one US server, cron/ alone holds 2,222 files, and sessions/ holds dozens of 87 to 256 KB request dumps.

Where the hosts are and how they listen

Half of the hosts are in China. The rest spread across ten other countries.

CountryHostsShare
China4450.6%
United States1416.1%
Germany89.2%
Singapore89.2%
Indonesia44.6%
France, Japan, Canada2 each
South Korea, Malaysia, Netherlands1 each

Almost every exposure comes from a plain HTTP server on a non-standard port, bound to all interfaces.

PortHostsShare
80803843.7%
800089.2%
889989.2%
888878.0%
909044.6%
8765, 9999, 18080, 803 each3.4% each

How the subsystems fit together

The Hermes TUI gateway (tui_gateway/entry.py) and a policy router (runtime-controller/runtime_router.py) sit on top. Below them, four units work on their own: the Cron scheduler, the Kanban board manager, the skill and language-server executor, and the Curator. All four write into the same plaintext credential and snapshot files on disk.

Figure 1: Self-directed Hermes daemons coordinate four unattended subsystems
Figure 1: Self-directed Hermes daemons coordinate four unattended subsystems

The fullest example: one server, eight subsystems

A virtual server in Germany (Host A in Figure 4, Chapter 5) exposes all eight runtime subsystems at once. It lists 14,914 indexed files.

Exposed pathFilesWhat it shows
/.hermes/14,914Full tree: cron, kanban, curator, lsp, sessions, skills, logs, state-snapshots
/hermes-webui.old.*/.venv/883Virtual environment kept from an older Hermes WebUI install
/hermes-webui.old.*/tests/652A second WebUI backup left under the HTTP root
/.hermes/profiles/<name>/176A dedicated persona profile with its own config and state
/.hermes/logs/curator/26Past Curator run folders
/.config/ and project logs30Service configs (21 files) and agent-managed project logs (9 files)
/.hermes/.env1Root environment file holding a Telegram bot token

Two WebUI backups, a custom profile and 26 Curator entries point to a workbench that has been upgraded many times. This is a long-lived install, not a one-off test.

3. Task Boards, Schedules and 31 Tools

In short

Hermes replaces prompting with two scheduling tools: SQLite Kanban boards that hand cards to isolated workers, and a Cron dispatcher that runs scripts and model briefings on a timer. Monitor both on engineering hosts.

The tools the agent can call

Retry dumps on one server contain the agent's full tool list. Hermes registers 31 tools in five groups.

GroupCountToolsWhat they allow
Headless browser10browser_navigate, browser_snapshot, browser_vision, browser_click and 6 DOM or tab helpersDrive a Chromium browser and read pages visually
Scheduling and delegation4cronjob, delegate_task, mixture_of_agents, todoSchedule jobs, fan out to sub-agents, track cards
Code and shell5execute_code, terminal, process, patch, write_fileRun shell commands, manage processes, patch files
Files and retrieval5read_file, search_files, session_search, web_extract, web_searchSearch local files and past sessions, scrape the web
Memory, skills and messaging7memory, skill_manage, skill_view, skills_list, send_message and 2 runtime helpersUpdate memory, prune skills, push to Telegram or Discord

An agent with terminal, cronjob and send_message can run shell commands on a timer and report the results to a chat bot. No person needs to be present.

Figure 2: Five exposed path families map daemon mechanics to defender signals
Figure 2: Five exposed path families map daemon mechanics to defender signals

Kanban boards and Cron jobs

Multi-subsystem hosts pair a cron-pipelines skill with two Kanban skills: kanban-orchestrator and kanban-worker. The orchestrator breaks a project into SQLite cards. Each worker runs a card in its own workspaces/t_<id>/ folder. Task state lives in kanban.db and in one kanban.db per board.

The Cron dispatcher reads cron/jobs.json. It runs two kinds of job. Some are plain no_agent Python scripts, guarded by .tick.lock and logged in executions.db. Others call the model and push a briefing to Telegram.

Host (country)Exposed pathFiles or sizeWhat it holds
Host C (KR)kanban/boards/<board>/76 files, 258,048-byte DBLive board database and task cards
Host C (KR)kanban/boards/_archived/82 files, 105,904-byte logArchived worker folders and worker logs
Host C (KR)cron/output/<job_id>/1 fileScheduled Markdown summary that records a callback endpoint
Host D (DE)kanban/boards/49 filesTwo German-language project boards (23 and 26 files)
Host B (US)cron/, jobs.json2,222 files, 12,048-byte JSONAn hourly no_agent fetch job and a thrice-weekly report job
Host E (US)cron/output/<job_id>/88 filesScheduled output, with four Telegram bot tokens in .hermes_history
Host G (CN)kanban.db, cron/executions.db143,360 bytes in totalTask board (118,784 bytes) and Cron execution log (24,576 bytes)

Job IDs, board names and script names are withheld.

Skills that reach beyond the agent

The skill manifest on one US server (.skills_prompt_snapshot.json, 57,659 bytes) shows how Hermes extends its own tools.

  • Delegation to other coding agents. Hermes ships playbooks for claude-code, codex and opencode. They tell the daemon to start separate Claude Code or OpenAI Codex CLI processes for multi-PR coding work. The same US server also exposes a /.codex/ folder with 688 files, including the codex-linux-sandbox and codex-execve-wrapper binaries. A Korean server has the Claude Code CLI wrapper installed under /.hermes/node/lib/node_modules/.
  • Terminal email. Several servers stage skills/email/himalaya/. This playbook wires the Rust himalaya client into the terminal tool, so the agent can read IMAP mail and send through SMTP. The same hosts stage skills/mcp/native-mcp/ and skills/red-teaming/.

4. Curator Runs, Retry Dumps and Snapshots

In short

Hermes keeps three kinds of file that outlive a key rotation: Curator run logs, raw retry dumps and pre-update snapshots. Rotating a key is not enough; these files must be purged too.

Figure 3: Scheduled Cron jobs, Kanban workers and retry dumps run without humans
Figure 3: Scheduled Cron jobs, Kanban workers and retry dumps run without humans

Inside one Curator run

The Curator is the second most common background subsystem after logs. It appears on 41 hosts (47.1%), in 124 directory entries. It reviews the skills the agent has written and merges or archives them.

A Korean server (Host C in Figure 4, Chapter 5) exposes one full run. The run log, run.json, is 34,236 bytes. The summary, REPORT.md, is 8,294 bytes. The log carries its own timestamp of 17 June 2026. The run took 591.25 seconds (9 minutes 51 seconds) and used model gpt-5.4 through provider copilot.

StageWhat happened
1. Pre-checkReviewed 68 agent-written skills without calling the model. None were marked stale or reactivated; one was seeded.
2. Model passMade 90 tool calls: skill_manage 35, read_file 31, terminal 12, search_files 6, skill_view 5, execute_code 1. Merged nine skill clusters into broader skills.
3. Clean-upFound a missing path, located the support files with terminal and moved them. Archived 26 skills (68 down to 42) into skills/.archive/, which exposes 100 files. Rewrote no Cron jobs.

The merges are ordinary engineering housekeeping. kanban-orchestrator and kanban-worker became kanban-operations. Six GitHub skills became github-operations. Debugging, document and travel-planning skills were also combined. The point for defenders is that the agent edits its own playbooks and runs shell commands while nobody watches.

Four files that hold secrets

MechanismFile and sizeWhen it is writtenWhat it keeps
Retry dumpsessions/request_dump_*.json, 87 to 256 KB eachUpstream HTTP 503 or timeout (max_retries_exhausted)The full POST /v1/chat/completions body sent to inference-api.nousresearch[.]com, with the Authorization: Bearer header, SOUL.md, MEMORY.md, 31 tool definitions and terminal output
Pre-update snapshotstate-snapshots/*-pre-update/.envAutomatically before hermes updateOlder .env and config.yaml with Anthropic, OpenRouter, Telegram and Discord keys
Config backups.env.bak.* (23,157 bytes) and 8 config.yaml.bak.* copiesConfig or router editsPlaintext key rings and provider fallback lists across many edits
Crash logslogs/tui_gateway_crash.log (219,915 bytes) and gateway-exit-diag.log (40,786 bytes)SIGTERM to the gatewayThread stacks, module paths, process IDs and restart rhythm

The retry dump is the most direct leak. One case on the US server (Host B in Figure 4, Chapter 5) shows how it happens. A user asked Hermes, in Chinese, to report the current fallback provider and model without showing any API key. The agent searched state-snapshots/ and old request dumps.

The upstream model (deepseek/deepseek-v4-flash) then returned HTTP 503. The gateway wrote the whole 256,668-byte request to sessions/, bearer header included. The user's request to hide the key did not stop the client from saving it.

5. Shared Servers: Agent State Next to TLS Keys

In short

An open file server in /root does not stop at .hermes. On one US server it also exposed web-panel TLS private keys, a Codex install and backups; on a Korean server it exposed PM2 web workers.

Figure 4: Flagship servers pair autonomous Hermes stacks with co-hosted TLS keys and PM2 apps
Figure 4: Flagship servers pair autonomous Hermes stacks with co-hosted TLS keys and PM2 apps

Language servers on seven hosts

Seven hosts stage ~/.hermes/lsp/, a headless Language Server Protocol toolchain. On the Korean server it holds 1,791 files. It lets the agent navigate and refactor code across services on the same machine. A US server also carries lsp/package.json.

The US server: Hermes, Codex and ACME keys under one root

The US virtual server (Host B) exposes 30 open-directory sites. A retry dump dated May 2026 contains a ps aux listing captured by the agent's own terminal tool. It shows a bash login shell that changed into /root and started a Python script importing http.server.

That script served a generated analytics dashboard from /root on a high TCP port. Because http.server has no path limits, it served everything else in /root too. The files cannot tell us whether the owner or the agent started the listener.

Exposed folderFilesWhat it holds
/.hermes/7,6432,222 Cron files with jobs.json, kanban.db (114,688 bytes), runtime_router.py, .env (23,252 bytes), retry dumps and a pre-update snapshot
/ and /backups/6,2585,974 root files plus 284 backup files, including a recovery archive and project archives
/.codex/688OpenAI Codex CLI: logs_2.sqlite-wal (4.19 MB), shell snapshots, sessions and sandbox binaries
/.acme.sh/277169 DNS API hooks, 26 notification scripts and two ECDSA ec-256 certificate folders
Panel domain 2 _ecc/10Private key (227 bytes), privkey.pem, backup/key.bak, fullchain.cer and a .conf with Le_Webroot='dns_cf'
Panel domain 1 _ecc/6Private key, seen on 18 November 2026

The certificate request config for the second domain sets extendedKeyUsage=serverAuth,clientAuth. Both certificates were issued through Cloudflare DNS-01 validation (dns_cf). Anyone holding these keys could impersonate the two web panels until the certificates are revoked.

The folders share a root, but that is all the files show. They do not tell us whether the agent managed the panels, or who runs the server.

The Korean server: Kanban, Curator and PM2

The Korean server exposes 86 open-directory sites and 4,774 files across six Hermes subsystems.

ComponentFilesNote
Active Kanban board76Includes the 258,048-byte kanban.db
Archived boards82Worker folders and logs
lsp/1,791Language server runtime
node/lib/1,779Node.js modules, including the Claude Code CLI wrapper
Curator runs2 foldersIncludes the run described in Chapter 4
/.pm2/17PM2 logs, including dashboard-error.log, for Node and Express workers bound locally
Application folder7Name withheld
/.hermes/.env1Holds a Discord bot token

Multi-profile servers

A third US server (Host F) lists 8,440 files across four subsystems: curator, logs, lsp and skills. It runs separate bot profiles under profiles/<name>/.env. One profile holds a DeepSeek API key and a Telegram bot token. A Chinese server shows the same profile layout.

6. Separating Real Daemons From Skill Mirrors

In short

Skill folders are the most common path but the weakest signal. Logs and Curator runs mark a working daemon; task boards, schedules, dumps and keys mark a host that needs action.

Figure 5: Logs and Curator runs anchor 47 daemons while skills inflate raw counts
Figure 5: Logs and Curator runs anchor 47 daemons while skills inflate raw counts

Why skills inflate the count

The skills/ folder makes up 499 of 1,100 entries (45.4%) and appears on 68 hosts. Much of it is bundled open-source documentation. Some bundled docs contain example strings that look like secrets, such as localhost REST examples. Alerting on every /.hermes/ path would flood analysts with this material.

Logs (57 hosts) and Curator runs (41 hosts) are better markers of a running daemon. Task boards, Cron files, retry dumps and private keys are the paths that call for containment.

The verified secret findings

Eleven secret findings are verified against the original files. They hold 10 distinct values, because one private key appears in two files. All 11 are real exposures; none is a test fixture.

TypeCount
TLS private keys3
Telegram bot tokens2
Callback endpoint strings2
Anthropic API key1
DeepSeek API key1
Discord bot token1
Pastebin drop link1

Seven of the 11 are application or corporate secrets: the three key files, root .env files and a profile token. Four come from agent session files: request dumps, snapshot .env files and Cron output. This is a verified sample, not a census. We do not claim a ratio of real secrets to fixtures.

Four kinds of host (analytical model)

The table below is our analytical model. It groups the 87 hosts by what their files show. The files record what was on disk, not what the owner intended.

Model groupHostsShareWhat the files showSuggested response
H1: Static skills or minimal config2528.7%19 hosts expose only skills/ (one lists 11,899 static files); 6 expose root .env or auth.json without logsSuppress skill hits; review only if .env or auth.json is exposed
H2: Active gateway with logs or memory1517.2%logs/ or memories/ next to skills/, but no Curator, Kanban or CronRotate exposed model and bot keys; close the listener
H3: Self-directed workflow daemon4652.9%32 Curator or snapshot hosts plus 14 multi-subsystem Kanban, Cron or language-server hostsCheck egress for unsanctioned automation; purge snapshots and dumps when rotating keys
H4: Daemon plus co-hosted web-panel keys11.1%The US server with 7,643 Hermes files, 2,222 Cron files, Codex and two ACME key foldersRevoke the TLS certificates and bot tokens; move acme.sh out of /root

H3 and H4 together are the 47 hosts with background subsystems.

Other explanations to weigh

Three explanations apply across all four groups. None of them points to an attack.

  • Authorized testing. Some hosts stage skills/red-teaming/ playbooks next to normal developer tools. Offensive skill templates inside a bundled skill tree fit an authorized test bench or a default checkout. They do not show intrusion activity.
  • Research benches. Heavy Curator use (41 hosts) and Kanban use (4 hosts), including the multi-profile servers, fit engineering teams or labs testing unattended agent memory and task splitting.
  • Decoys and unconfigured mirrors. Some of the 25 static H1 hosts may be decoys or unused mirrors that attract scanners.

Across all groups, the files record past runs and local configuration. They do not show attacks on third-party networks.

7. What Defenders Should Do

Within 24 hours

  • Deny hidden-folder URIs at the web edge (Nginx, Caddy, Apache, CDN). Requests for /.hermes, /.acme.sh, /.pm2 and /.codex should return 403 or 404, with autoindex off.
  • Find and stop non-loopback python3 -m http.server processes, or scripts that import http.server, running in /root or /home/. Local previews must use --bind 127.0.0.1.
  • If you find your own host in this pattern, revoke any TLS certificate whose key sat in an exposed acme.sh folder.

Within 72 hours

  • Move acme.sh keys out of home folders, for example with --cert-home /etc/ssl/acme, and set chmod 600.
  • Each time you rotate a model, Telegram or Discord token, also delete sessions/request_dump_*.json, state-snapshots/*-pre-update/.env and .env.bak.*.
  • Review himalaya mail credentials, and the permissions of any claude-code or codex sub-process, on shared hosts.

Within 7 to 30 days

  • Register every unattended agent Cron job and Kanban board as a service account. Give it token spend caps and an egress allowlist.
  • Deploy the Suricata signatures 9516001 to 9516010 and check that 9516005 excludes /skills/.
  • Compare internal vault entries against exposed-secret alerts, and check certificate transparency logs for unexpected certificates on your panel domains.

8. Detection Rules

The full rules are in the Detection rules tab. Each rule excludes the bundled Hermes skills folder or loopback traffic, so static mirrors and local previews do not fire.

Rule fileWhat it catches
odin_hermes_daemon_and_panel_exposure.rulesSuricata 7: ten signatures for requests to Hermes daemon paths and acme.sh keys, and for responses that deliver keys, configs, dumps or directory listings
sentinel_unattended_ai_daemon_cron_and_acme_leak.kqlMicrosoft Sentinel and Defender XDR: open file-server commands, writes to daemon and key files, unattended Hermes processes, and listeners on daemon ports
sigma_hermes_autonomous_agent_cron_and_daemon.ymlSigma (3 rules): Hermes gateway and Curator processes, web servers returning daemon files or keys, and ad-hoc file servers in dotfile paths
odin_hermes_kanban_curator_and_request_dumps.yarYARA (4 rules): Curator run files, retry dumps and crash logs, Kanban and Cron stores, and ACME key material

How the Suricata signatures work

Signatures 9516001 to 9516006 watch requests. Each one sets a flowbit. Signatures 9516007 to 9516009 only fire on a 200 response in a flow where that flowbit is set. Suricata 7.0 or later is needed, with the http.uri, http.stat_code and file.data buffers.

SIDLooks forWhy
9516001GET for /.hermes/kanban with /boards/, kanban.db or /workspaces/t_<hex>Task board and worker folders (T1213)
9516002GET for /.hermes/cron/ with jobs.json, executions.db, .tick.lock or /output/Scheduler jobs and output (T1213)
9516003GET for /.hermes/logs/curator/ with run.json, REPORT.md or a dated run folderCurator runs (T1213)
9516004GET for request_dump_*.json under /.hermes/sessions/Retry dumps with bearer headers (T1552.001)
9516005GET under /.hermes/ for state-snapshots/, a profile auth.json or .env, or tui_gateway_crash.log, excluding /skills/Snapshot and profile secrets (T1552.001)
9516006GET under /.acme.sh/ for .key, privkey.pem, key.bak or an _ecc .confCertificate keys and DNS-01 configs (T1552.004)
9516007200 response body with -----BEGIN ... PRIVATE KEY-----A private key was actually served
9516008200 response body with Le_RealKeyPath= and Le_Webroot= or Le_Keylength=An acme.sh domain config was served
9516009200 response body with Hermes Agent Persona and max_retries_exhausted or upstream_timeoutA retry dump was served
9516010200 listing (Index of / or Directory listing for /) that links to .hermes/ or .acme.sh/An open directory exposing either folder

Suppress your own authorized attack-surface scanners by exact source address in threshold.conf, not by CIDR ranges.

How the other rules work

The KQL query has four branches and a 14-day lookback. Results are grouped per device and day, and device-days with two or more distinct signals come first.

BranchLooks for
Processhttp.server, SimpleHTTPServer, http-server, npx serve or miniserve started from /root, /home/, .hermes or .acme.sh, without a loopback bind
FileFiles created, changed or renamed under .hermes daemon folders or acme.sh .key files
Daemontui_gateway/entry.py, runtime_router.py, hermes curator or kanban-orchestrator, or a Hermes parent that starts himalaya or acme.sh
NetworkA web-server process listening on a daemon port (for example 8080, 8899, 8765, 18080) on a non-loopback address, or accepting public connections

The network branch matters because a custom wrapper script can import http.server without naming it on the command line. Fill the ApprovedInternalBuildHosts list with exact host names of sanctioned automation runners.

The three Sigma rules need Linux auditd and web access logs. The first flags Hermes gateway, router and Curator processes, excluding pytest. The second flags a web server returning 200 for daemon files or acme.sh key files; check cs-username to confirm anonymous access. The third flags non-loopback file servers or root Python wrappers in dotfile paths.

YARA ruleFires on
ODIN_Hermes_Curator_Distillation_Run_And_ReportCurator run.json and REPORT.md content
ODIN_Hermes_Request_Dump_And_Gateway_CrashRetry dumps and gateway crash logs
ODIN_Hermes_Kanban_Board_And_Cron_SchedulerKanban SQLite databases and Cron job stores
ODIN_Cohosted_Panel_ACME_TLS_Materialacme.sh key and config files

Each YARA rule is limited to files under 20 MB and needs YARA 4.3 or later.

What triage seesAction
Listener bound to loopback onlyIgnore: local development
Only skills/ or node_modules/ pathsCompare with the upstream package before closing
Gateway logs or a root .envReview and rotate keys
Any Kanban, Cron, Curator or retry-dump pathTreat as an unattended daemon exposure
Daemon paths plus an exposed acme.sh .key or private keyMost urgent: revoke certificates and tokens

Every rule file loads without errors in its engine (Suricata 7.0.12, YARA-X, pySigma, Kusto.Language); the rules were not replayed against live traffic. Their logic was checked in Python against sample files and negative controls. Load and test each rule in staging before production use.

9. Indicators

No indicator from this study is published as a value. All 28 point to exposed owners, not to attackers.

TypeCountStatus
Flagship exposed Hermes hosts (Hosts A to F)6Withheld: exposed owners
Co-hosted web-panel domains2Withheld: exposed owners
File hashes of exposed key, database, Cron, Curator, dump and crash-log files10Withheld: owners' files
Hashes of exposed secret values10Withheld: secret material

Host G and the other labelled hosts appear in the text but are not counted as indicators.

Withheld: all host addresses and ports, both panel domains, board, job, profile and script names, and every file or secret-value hash.

What to hunt for instead

The patterns below are stable across installs and safe to publish.

PatternWhere to lookTypical size
/.hermes/kanban.db, kanban/boards/<slug>/kanban.dbWeb logs, file scans114,688 to 258,048 bytes
/.hermes/cron/jobs.json, cron/executions.dbWeb logs, file scans12,048 and 24,576 bytes
/.hermes/logs/curator/<run>/run.json, REPORT.mdWeb logs, file scans34,236 and 8,294 bytes
/.hermes/sessions/request_dump_*.jsonWeb logs, file scans87 to 256 KB
/.hermes/logs/tui_gateway_crash.logWeb logs, file scans219,915 bytes
/.hermes/state-snapshots/*-pre-update/.env, .env.bak.*Web logs, file scans23,157 bytes for one backup
/.acme.sh/*_ecc/*.key, privkey.pem, backup/key.bakWeb logs, file scans227 bytes for one key
Directory listing for / or Index of / linking to .hermes/HTTP responsesn/a

MITRE ATT&CK mapping

These techniques describe what an attacker could do with the exposed files. They do not mean the owners were attacked.

TacticTechniqueExposureDetection
CollectionT1213 Data from Information RepositoriesKanban boards, Cron stores and Curator runs readable over HTTPSIDs 9516001 to 9516003, 9516010; Sigma rule 2
Credential AccessT1552.001 Unsecured Credentials: Credentials In FilesBearer headers in retry dumps; keys in .env, snapshots and backupsSIDs 9516004, 9516005, 9516009; YARA dump rule
Credential AccessT1552.004 Unsecured Credentials: Private Keysacme.sh ECDSA keys for two web-panel domainsSIDs 9516006 to 9516008; YARA ACME rule

10. Scope and Limits

  • Window. The findings come from a two-week observation window ending 18 November 2026. Files on the exposed servers carry their own earlier dates. These include a retry dump dated May 2026 and a Curator run log dated 17 June 2026, both written by the agents themselves. Some servers were first listed before this window; no dates are given for those listings. They are file timestamps, not the span of our observation.
  • A sample, not a census. The counts describe these hosts, not every Hermes install online.
  • Files, not activity. Directory listings show what was stored on disk. They do not show running processes, intent, or whether a scheduled job ran at a given time.
  • Owners are not attackers. All 87 hosts are exposed systems. Red-team skills on some hosts fit authorized testing as well as misuse.
  • No downstream compromise shown. Nothing here shows a breach of the model providers, of the panel domains' users, or of any third-party network.
  • Unknown listener origin. On the US server, the files cannot tell us whether a person or the agent started the file server.
  • Verified secrets only. The 11 secret findings are those matched to original files. Other secrets may exist on these hosts.
  • Rule testing. Every published rule file loads without errors in its engine (Suricata 7.0.12, YARA-X, pySigma and Microsoft's Kusto.Language analyzer, checked on 20 November 2026). The rules were not replayed against live traffic, so test and tune them in your own environment before production use.

11. Sources

  1. Nous Research. Hermes Agent documentation. https://hermes-agent.nousresearch.com/docs (verified 18 November 2026)
  2. Nous Research. hermes-agent repository. https://github.com/NousResearch/hermes-agent (verified 18 November 2026)
  3. acmesh-official. acme.sh repository. https://github.com/acmesh-official/acme.sh (verified 18 November 2026)
  4. PM2. Quick start and log management. https://pm2.keymetrics.io/docs/usage/quick-start/ (verified 18 November 2026)
  5. Pimalaya. Himalaya CLI email client. https://github.com/pimalaya/himalaya (verified 18 November 2026)
  6. MITRE ATT&CK. T1213 Data from Information Repositories. https://attack.mitre.org/techniques/T1213/ (verified 18 November 2026)
  7. MITRE ATT&CK. T1552.004 Unsecured Credentials: Private Keys. https://attack.mitre.org/techniques/T1552/004/ (verified 18 November 2026)
  8. Python Software Foundation. http.server documentation and security warning. https://docs.python.org/3/library/http.server.html (verified 18 November 2026)

What is…?

Short explanations of the tools and families named in this study.

All explanations

Frequently asked questions

What does an unattended agent leave behind?

Hermes keeps its state in a hidden ~/.hermes folder. On a busy install, that folder holds far more than chat history. One server in Germany exposes all eight subsystems in 14,914 files. Two old WebUI backups and 26 Curator entries show it has been upgraded and used for a long time.

How do keys end up on disk?

Three Hermes features keep secrets long after an owner thinks they are gone. On one US server, a user asked the agent to report its fallback model without showing any key. The upstream model then failed, and the gateway saved the full request, bearer header included, to disk.

Why does one open folder expose the whole server?

Most of these servers run a simple HTTP server on a high port: 38 of the 87 use 8080. When that server starts in /root, it serves everything next to .hermes as well.

Is every exposed Hermes folder a problem?

No. The skills folder is the most common path, at 499 of 1,100 directory entries. Much of it is bundled documentation. Our analytical model puts 25 hosts (28.7%) in a static group with only skills or a minimal config.

Defender kit

Indicators of compromise

Verified adversary infrastructure and tool hashes from this study. Every value below is also discussed in the report.

No network or file indicators are published for this study

The hosts in this report are exposed or unattributed systems rather than confirmed adversary infrastructure, so they stay anonymous. Use the detection rules below to find the same exposure in your own estate.

28 records from this study are not published in this table: candidate, suspected and dual-use hosts, victim-related values, and hashes of exposed secrets or files.

Defender kit

Detection rules

The rule files exactly as printed in the report. Test them in your own engine before deployment.

Suricata odin_hermes_daemon_and_panel_exposure.rules 40 lines
Download
YARA odin_hermes_kanban_curator_and_request_dumps.yar 102 lines
Download
Sentinel KQL sentinel_unattended_ai_daemon_cron_and_acme_leak.kql 77 lines
Download
Sigma sigma_hermes_autonomous_agent_cron_and_daemon.yml 117 lines
Download