1. Executive Summary
In short
Odin by Brandefense found 112 servers that expose the hidden home folders of five AI coding and task agents over plain HTTP. One hundred of them hold real user files. These folders keep full session transcripts, compaction summaries and backup copies, so API keys and bot tokens survive cleanup. A quarter of the servers run two or three agents and reuse keys across them. Block non-loopback file servers, deny dotfile paths at the proxy, and wipe agent session folders whenever you rotate keys.
Developers now run AI coding agents on rented Linux servers instead of laptops. They paste API keys, cloud tokens and database URLs into the agent's conversation. The agent writes all of it to hidden folders in the home directory. When the owner later starts a quick file server in that home folder, every one of those files can be downloaded by anyone.
AI agents keep secrets in transcripts, summaries and backups, not just config files.
Session logs, automatic context summaries, pre-edit file history and reset backups all hold full keys and shell output. Closing the terminal or resetting the session does not remove them. One open file server publishes all of it.
Nearly one quarter of exposed servers run two or three AI agents together.
Of the 112 servers, 26 (23.2%) host two or three agent stacks in the same account. On several of them, the same API key or bot token appears in more than one agent. Rotating the key in one config file is not enough.
Bundled skill files inflate secret scans.
Open-source skill packs ship example keys and local URLs, above all in Hermes folders. Defenders who scan agent folders must exclude them before opening an incident.
Three Decisions for Leaders
- Ban non-loopback file servers on engineering and cloud hosts. Block unauthenticated directory servers bound to all interfaces on ports such as 4000, 8000, 8080, 8888 and 9999. Deny hidden dotfile paths at every reverse proxy.
- Treat agent session folders as secret stores. Subagent summaries, file history and backup snapshots hold the same keys as config files. Wipe them every time a key, token or SSH key is rotated.
- Route exposed servers to remediation, not to block lists. Most of these servers belong to careless developers. Exclude bundled skill documentation from scans, rotate the exposed keys, and fix the server.
The Study in Numbers
| Number | What it is |
|---|---|
| 112 | Servers exposing hidden AI agent folders over HTTP; 100 of them hold real user files |
| 3,145 | Secret and session matches, excluding bundled skill documentation (some vendor source matches remain) |
| 695 | User session, subagent, tool and credential file paths |
| 26 (23.2%) | Servers running two (20) or three (6) AI agent stacks side by side |
| 919 / 553 | AI model keys and command-and-control or callback URLs, the two largest match categories |
| 83 (74.1%) | Servers that most likely belong to developers who exposed their home folder by mistake |
How to use this report.
Security leaders can read Chapter 1, Chapter 8 and Chapter 11. Cloud and DevSecOps teams should read Chapters 2 to 6 for the file layouts. SOC and detection engineers should start with Chapters 8 and 9.
2. How AI Agents Store Their Memory on Disk
In short
Each agent writes its conversations, tool output and credentials to a hidden folder in the user's home directory. A quick file server started in that home directory turns those folders into a public download.
How the exposure happens
Developers rent Linux virtual private servers (VPS) and install several command-line agents under /root or /home/<user>. To move files or preview a web build, they run python3 -m http.server or turn on Nginx autoindex on in their home folder. Neither tool hides dotfile folders. Every agent folder becomes readable over HTTP without a password.
The five agents in this study use these folders:
| Agent | Hidden folder | What it is |
|---|---|---|
| Claude Code | /.claude/ | Anthropic command-line coding agent with subagents |
| Hermes Agent | /.hermes/ | Open-source autonomous agent with multi-profile bots and skill packs |
| OpenClaw | /.openclaw/ | Open-source autonomous agent gateway with trajectories and auth profiles |
| Cursor IDE | /.cursor/ and /.cursor-server/ | IDE with remote SSH server and agent transcripts |
| OpenAI Codex CLI | /.codex/ | OpenAI command-line coding agent with rollout logs |
Matches by agent
The five folders hold 3,145 secret and session matches on 112 servers, excluding bundled skill documentation.
| Agent | Matches | Servers (with user files) |
|---|---|---|
| Claude Code | 988 | 26 (25) |
| Hermes Agent | 967 | 75 (58) |
| OpenClaw | 932 | 21 (19) |
| Cursor IDE | 184 | 6 (3) |
| OpenAI Codex CLI | 74 | 16 (14) |
The server counts add up to 144 agent installs on 112 servers, because 26 servers run more than one agent. On the 99 servers whose earlier directory listings show user files, there are 119 installs.
Hermes appears on the most servers, but few matches per server. On 11 single-agent Hermes servers, the snapshot held only bundled OpenSSL or npm files or upstream source code. Claude Code and OpenClaw tell the opposite story. They show few servers but many secrets per server, mostly inside live .jsonl session logs.
Separating user files from vendor files
The servers expose 695 user-state host and path pairs. Vendor bundles and upstream runtime source are not counted as user data. They include 29 copies of /.hermes/hermes-agent/agent/redact.py, the module Hermes uses to hide secrets.
The other 695 pairs are user sessions, subagent files, tool output and credential stores. Thirteen single-agent servers held only vendor or source paths in their earlier listing, which leaves 99 servers with user files. A full listing of Host H dated 18 November 2026 adds a Hermes session log, for 100 servers in total.
The earlier listings and the November listings count different things, so no combined match total is given. The 3,145 figure counts matches, not confirmed leaks.
Four layers of agent memory
The 695 user paths fall into four layers.

| Layer | Paths | What it holds | Example files |
|---|---|---|---|
| Primary session | 209 | Full conversation: prompts, pasted .env blocks, MCP parameters, raw tool output | /.claude/projects/<slug>/<uuid>.jsonl, .trajectory.jsonl, rollout-*.jsonl |
| Compaction and side-query subagents | 26 (12 compaction, 14 side-query and task) | Summaries written when the context window fills, and parallel side questions | subagents/agent-acompact-*.jsonl, agent-aside_question-*.jsonl |
| Tool execution | 58 | Shell commands, metadata queries, MCP database calls and their output | shell_snapshots/*.sh, tool-results/*.txt |
| Persistent credential and backup stores | 402 (218 secret stores, 172 backup or history snapshots, 12 memory notes) | OAuth tokens, API keys, pre-reset backups, Markdown notes | .credentials.json, auth.json, auth-profiles.json, .jsonl.bak-* |
The compaction layer matters most for cleanup. When a session fills its context window, Claude Code starts an agent-acompact-* subagent. It writes a dense summary of the work so far to a new file. Keys, Tailscale tokens and command-and-control (C2) URLs in the earlier turns carry over into that summary. They stay on disk even after the user deletes the original script. Whether these credentials still worked was not tested.
Which ports the servers use
These servers rarely use port 443. They sit on development ports that match python3 -m http.server, miniserve or a container preview.
| Port | Servers | Share of 112 |
|---|---|---|
| 8080 | 44 | 39.3% |
| 8888 | 11 | 9.8% |
| 8000 | 10 | 8.9% |
| 8899 | 9 | 8.0% |
| 80 | 5 | 4.5% |
| 9999 (4), 8081 (4), 18080 (3), 4000 (2), 19999 (2) | 15 | |
| Other high ports, such as 3000, 3003, 8090, 8091, 9090, 9123 | 18 |
3. What Leaks: Secret Categories
In short
AI model keys and C2 or callback URLs make up nearly half of all matches. The most damaging finds are the infrastructure secrets that let someone move further: SSH keys, GitHub tokens, cloud tokens and mesh VPN keys.

The categories
The 3,145 matches cover 34 secret types, grouped below. Some vendor source matches are still inside these counts.
| Category | Matches | Share | Leading types |
|---|---|---|---|
| AI model keys | 919 | 29.2% | DeepSeek (425), Stability AI (204), Anthropic (110), OpenRouter (102), OpenAI (72) |
| C2 and callback URLs | 553 | 17.6% | C2-pattern endpoints (550), reverse shell strings (3) |
| Generic passwords and secrets | 374 | 11.9% | Passwords (195), generic secrets (179) |
| Database and SaaS | 357 | 11.4% | Airtable keys (266), database connection strings (91) |
| Bot and drop channels | 353 | 11.2% | Telegram bot tokens (285), Discord bot tokens (42), out-of-band callbacks (16), Pastebin drops (10) |
| Cloud and mesh access | 251 | 8.0% | Google API keys (115), GCP OAuth secrets (67), DigitalOcean tokens (48), Vultr keys (14), GCP application default credentials (2) |
| Crypto and SSH keys | 215 | 6.8% | Private keys (98), Tailscale keys (48), JWTs (45), BIP-39 seed phrases (23) |
| Source control | 111 | 3.5% | GitHub tokens (90), GitHub personal access tokens (21) |
| Exchange and monitoring | 12 | 0.4% | Binance keys (8), Sentry DSNs (4) |
The "C2 and callback" label describes the URL pattern. It does not prove that each URL is attacker infrastructure. Many are webhooks or test endpoints the agent was asked to work with.
Which secrets matter most
AI provider keys and C2-pattern URLs account for nearly half of all matches. Damage, however, depends on what lets someone move further. These are the lateral secrets in the set:
| Secret | Count | Note |
|---|---|---|
| PEM private keys | Up to 68 | 98 matches minus 30 that are regex patterns inside redact.py source code; not yet checked for other bundle rows |
| GitHub tokens | 111 | Source code and CI access |
| GCP OAuth secrets | 67 | Cloud project access |
| DigitalOcean tokens | 48 | Droplet and account control |
| Tailscale keys | 48 | Entry into a private mesh network |
| Telegram and Discord bot tokens | 327 | Control of the bots and their message channels |
4. Case Study: One Workspace on Two Servers
In short
Two European VPS servers expose the same Claude Code workspace. One block of credentials appears in the main sessions, six compaction summaries, two side-query logs, file history snapshots and a Markdown memory note.
What the two servers share
Host A and Host B sit on European VPS networks. Host A shows 258 matches and Host B shows 254. Both expose the same Claude Code project folder name and the same session and subagent file names. That points to one /home/<user>/.claude workspace copied to two separate servers.
When the workspace was copied between the two servers is unknown.
The file layers on Host A and Host B
| Layer | Path pattern under /.claude/ | Present on | Role and secrets |
|---|---|---|---|
| OAuth store | .credentials.json | Host A | Claude OAuth access token, refresh token and scopes |
| Pre-edit file history | file-history/<session>/<snapshot>@v2, @v3 | Both | Versioned copies of scripts before secrets were removed |
| Primary sessions | projects/<slug>/<uuid>.jsonl (three sessions; a fourth on Host B) | Both | Full transcripts with Anthropic, OpenAI and Telegram keys |
| Compaction subagents | projects/<slug>/<uuid>/subagents/agent-acompact-*.jsonl (six files) | Both | Summaries that concentrate GCP OAuth, DigitalOcean, GitHub and Tailscale keys |
| Side-query workers | .../subagents/agent-aside_question-*.jsonl (two files) | Both | Side questions saved to disk next to the parent session's tokens |
| Memory note | projects/<slug>/memory/*.md | Both | A plaintext Markdown sheet listing cloud and bot credentials |
Why the counts repeat
On Host A, seven provider and bot token types each show exactly 28 matches. The host also shows 44 C2-pattern URLs and 15 password matches. The uniform count of 28 comes from copying, not from 28 different keys.
One multi-cloud credential block in the Markdown memory note was copied into the primary sessions. It was copied again into six compaction files, two side-query logs and two file-history versions. Each copy counts as a new match.
On Host B, the copied workspace adds one more session file. Its C2-pattern URLs rise from 44 to 67.
The lesson for responders: deleting the memory note does not remove the keys. They also live in every compaction summary, side query and history snapshot.
5. Backups, Trajectories and Resets
In short
Autonomous agents record shell probes and cloud metadata output, and they write append-only backup files. Resetting a session leaves its old secrets in sibling backup files.
Many engineers assume that an agent /reset command or a config edit removes exposed keys from disk. The files on these servers show the opposite. Agent runtimes checkpoint and back up their state to survive crashes and updates.

OpenClaw: trajectories, metadata probes and a reverse shell
Host C sits on a German cloud VPS network. Its exposed tree holds 285 files and 183 matches. It was listed again on 18 November 2026.
One OpenClaw session file on Host C records a query to the cloud instance metadata service (IMDS) at 169.254.169.254. It also records a listing of Chrome DevTools targets on the loopback address 127.0.0.1:9222. The same file holds GCP application default credentials, a Discord bot token and an inline Python socket reverse shell. A sibling .trajectory.jsonl file holds a GCP OAuth client secret.
These strings show that the agent discussed, generated or ran these commands on its own server. They do not show any breach of a third-party target.
Backup sprawl after resets
On Host C and two other OpenClaw servers, resetting a session left two kinds of copies behind. One is a .jsonl.bak-* file, which on Host C still held a Google API key. The other is a .jsonl.reset.* file. The same folders kept openclaw.json.bak through .bak.4, a .clobbered.* copy and a hand-named pre-fix backup.
Another OpenClaw server, Host D on an Asia-Pacific cloud VPS network, shows 158 matches. Of these, 154 are C2-pattern URLs. It pairs seven .trajectory.jsonl files with a cron run log under /.openclaw/cron/runs/.
Codex: auth files, rollouts and shell snapshots
Across 16 Codex servers (74 matches), the Codex CLI stores secrets in several places:
| File | What it holds |
|---|---|
/.codex/auth.json | Bearer tokens |
/.codex/agentrouter.env | Custom router keys |
/.codex/config.toml | Provider keys in TOML, including a DeepSeek key on one server |
/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl | Date-sharded session logs |
/.codex/shell_snapshots/*.sh | Saved shell state scripts |
Cursor and Hermes
Across 6 Cursor servers (184 matches), remote SSH sessions expose agent transcripts under /.cursor/projects/<slug>/agent-transcripts/. Three servers show them. Those servers also expose editor buffers under /.cursor-server/data/User/History/.
Hermes users split their bots into named profiles. Each profile has its own auth.json or .env under /.hermes/profiles/<profile>/. Hermes also writes raw request dumps to /.hermes/sessions/request_dump_*.json. Two Hermes servers with this layout show 61 and 70 matches.
Where the deepest reservoir sits
The persistent credential and backup layer holds 402 of the 695 user paths. That breaks down into 218 secret stores, 172 backup or history snapshots and 12 memory notes. Tool execution adds 58 more. Together these are the files most often missed during cleanup.
6. Co-Hosted Multi-Agent Servers
In short
Of the 112 servers, 26 (23.2%) run two or three AI agents in one home folder. On several of them, the same keys were copied across agents.
How many agents per server
Most servers run one agent, but a large minority stack several together.
| Agents per server | Servers | Share |
|---|---|---|
| One | 86 | 76.8% |
| Two | 20 | 17.9% |
| Three | 6 | 5.4% |
Which agents run together
| Stack | Servers | Share of 112 | Example server | Matches and notes |
|---|---|---|---|---|
| Hermes + OpenClaw | 6 | 5.4% | Host C, German VPS | 183 matches in 285 files; the same Anthropic and Discord keys in two agents, IMDS query, reverse shell string |
| Claude + Codex | 5 | 4.5% | Host B, European VPS | 254 matches; copied Claude subagent tree, Codex in the same home, 67 C2-pattern URLs |
| Claude + OpenClaw | 3 | 2.7% | US VPS | 70 matches; three custom OpenClaw personas and plugin catalogs |
| Claude + Hermes + OpenClaw | 2 | 1.8% | Host E, Asia-Pacific VPS | 156 matches; Claude memory note about OpenClaw bots, 88 C2-pattern URLs |
| Claude + Codex + OpenClaw | 2 | 1.8% | Host G, Asia-Pacific VPS | 97 matches; the same DeepSeek key in a Codex rollout and an OpenClaw script |
| Codex + Hermes | 2 | 1.8% | European VPS | 59 matches; /.codex/auth.json next to Hermes profile .env files |
| Claude + Hermes | 2 | 1.8% | Asia-Pacific VPS | 25 matches; Claude project history next to Hermes config backups |
| Claude + Codex + Cursor | 1 | 0.9% | Host F, Chinese VPS | 125 matches in 116 files; remote Cursor and VS Code IDE, Claude MCP and Codex CLI |
| Cursor + Hermes, Codex + Cursor, Claude + Codex + Hermes | 3 | 2.7% | Three servers | 8 to 17 matches each; remote Cursor SSH server next to CLI agents |

Three ways keys spread across agents
No key value or key hash is published.
Key copying between two agents (Host C).
OpenClaw stores provider keys for two agent profiles in /.openclaw/agents/main/agent/auth-profiles.json. Hermes keeps a pre-update .env copy under /.hermes/state-snapshots/. Both files hold the same Anthropic API key. An OpenClaw session file and that Hermes .env snapshot also hold the same Discord bot token.
One agent managing another (Host E and Host G).
Owners use Claude Code or Codex interactively to write and debug background OpenClaw or Hermes bots on the same server. On Host E, a Claude Code memory note about OpenClaw bots sits next to a pre-migration OpenClaw folder and 88 C2-pattern URLs. On Host G, a Codex rollout and an OpenClaw shell script contain the same DeepSeek key.
A full remote workstation (Host F).
Host F, on a Chinese cloud VPS network, combines remote Cursor and VS Code SSH servers with Claude Code MCP sessions and Codex CLI rollouts. Codex session files on the server carry dates up to 17 November 2026. The host exposes 86 Stability AI keys, 22 password records and 12 generic secrets.
For defenders, the rule is simple. When a key leaks from one agent folder, search every other agent folder on that host for the same key.
7. Bundled Files and Who Owns These Servers
In short
Secret scans that do not exclude skill packs overstate Hermes leaks, because those packs ship example keys and local URLs. Most exposed servers belong to careless developers, not attackers.
Treating every match in a dotfile folder as a live leak floods analysts with false alerts. Treating every exposed server as hostile blames careless engineers. Both mistakes are easy to avoid.
Bundled skill files
Across all servers, 266 distinct secret values were found. Of these, 135 turned out to be example values from open-source skill packs and test fixtures. The other 131 are session secrets. The 131 include low-entropy password values, which this report does not publish in any form.
Host H shows the effect on one server. It runs Hermes on a Chinese cloud VPS and exposes 22 files. Its full listing on 18 November 2026 held 31 distinct secret values. Twenty of them (64.5%) were bundled examples under /.hermes/skills/:
| Source | Values | What they are |
|---|---|---|
| ComfyUI skill reference | 16 | Local REST examples such as http://127.0.0.1:8188/queue, /interrupt and /system_stats in /.hermes/skills/creative/comfyui/references/rest-api.md |
| Other skill files | 4 | Placeholders in SKILL.md, backends.md and a skills backup archive |
| Hermes session log | 11 | One C2-pattern URL and ten password values in /.hermes/sessions/ |
Excluding /.hermes/skills/ removes all 20 examples and keeps the 11 real session values. An earlier listing of Host H showed only one match, a private-key regex pattern inside redact.py.
Who owns these servers
Ownership cannot be confirmed from exposed files alone. We weighed three explanations across the 112 servers. They are working hypotheses, not attributions.
| Hypothesis | Servers | What supports it | Response |
|---|---|---|---|
| H1: Developer or AI engineering server exposed by mistake | 83 (74.1%) | Single-agent installs serving SaaS, trading or study projects through an ad-hoc http.server | Fix the exposure and rotate keys; do not block permanently |
| H2: Multi-agent builder or red-team lab | 21 (18.8%) | Two or three IDE and CLI agents on one host (Host F, Host G and a US host), keys copied across tools, few C2-pattern URLs | Check corporate egress for accidental tunnel use; rotate matched keys |
| H3: Workbench with offensive content | 8 (7.1%) | Dense C2-pattern URLs (Hosts A, B, D, E and two others) or recorded metadata probes and a reverse shell (Host C) | Hunt egress logs for contact; check how long the cloud IP has been leased before any block |
Even in the H3 group, C2 and reverse shell strings in a session log show that an agent discussed, generated or ran those commands on the server. They do not confirm any breach of a third-party target. The owners of all 112 servers are treated as users, not operators.
8. What Defenders Should Do
Within 24 hours
- Search your own external attack surface for HTTP 200 responses on
/.claude/,/.codex/,/.cursor/,/.openclaw/and/.hermes/. - Add a reverse-proxy deny rule for these dotfile paths in Nginx, Caddy, Apache and CloudFront. Confirm that a request returns 403 or 404.
- Block public ingress to development ports 3000, 3003, 4000, 8000, 8080, 8091, 8888, 8899, 9090 and 9999 on cloud VPS and jump hosts.
Within 72 hours
- Require
--bind 127.0.0.1forpython3 -m http.server,npx serveand similar tools on engineering hosts. Alert on any launch in/rootor/home/that binds to all interfaces. - When rotating a key, also delete
subagents/agent-acompact-*.jsonl,file-history/,.jsonl.bak-*,.reset.*andshell_snapshots/in~/.claude/,~/.openclaw/and~/.codex/. - Replace hard-coded
DATABASE_URLvalues in~/.cursor/mcp.jsonand keys in agent memory notes with an OS keychain or short-lived vault injection.
Within 7 to 30 days
- Restrict cloud metadata access. Enforce IMDSv2 with hop limit 1 on AWS EC2, require the
Metadata-Flavor: Googleheader and workload identity on GCP, and use the token-hardened metadata mode on Alibaba ECS. On DigitalOcean and other Linux VPS hosts, block169.254.169.254with a per-user firewall rule. - Hash your own active Anthropic, OpenAI, GCP, Tailscale and bot keys, and check every agent folder on each engineering host for copies.
- Exclude
/.hermes/skills/,node_modules/and test fixtures from secret scanning before opening incidents. - Deploy the detection rules in Chapter 9 and confirm that all eight Suricata signatures load.
9. Detection Rules
The full rules are in the Detection rules tab. They cover both sides of the problem: your own engineers serving dotfiles, and outsiders fetching them.
| Rule file | What it catches |
|---|---|
odin_ai_agent_session_exposure.rules | Suricata 7: eight signatures for HTTP requests to agent credential and session paths, and for open directory listings that expose agent folders |
sentinel_ai_agent_workspace_exposure_hunt.kql | Microsoft Sentinel and Defender XDR: home-folder file servers on public interfaces, writes to agent secret files, agent-started metadata or reverse shell commands, and public connections to ad-hoc ports |
sigma_exposed_ai_coding_agent_http_serving.yml | Sigma (3 rules): non-loopback file servers in home folders, web log hits on agent dotfiles, and agent runtimes that start metadata probes or socket shells |
odin_exposed_ai_agent_session_artifacts.yar | YARA (4 rules): Claude credentials and compaction files, OpenClaw trajectories and auth profiles, Codex rollouts and auth files, Cursor MCP configs and Hermes session dumps |
How the Suricata signatures work
| SID | Looks for | ATT&CK |
|---|---|---|
| 9510001 | GET request for /.claude/.credentials.json | T1552.001 |
| 9510002 | GET under /.claude/projects/ for a .jsonl file, memory/ or tool-results/ | T1213 |
| 9510003 | GET for subagents/agent-acompact-*.jsonl | T1552.001 |
| 9510004 | GET under /.openclaw/agents/ for .jsonl, auth-profiles.json or models.json | T1552.001 |
| 9510005 | GET under /.codex/sessions/ for a rollout-*.jsonl file | T1213 |
| 9510006 | GET under /.cursor/ for mcp.json or an agent transcript | T1552.001 |
| 9510007 | GET under /.hermes/ for request dumps, session files, state snapshots or profile auth.json and .env, excluding /skills/ | T1552.001 |
| 9510008 | HTTP 200 directory listing ("Index of /" or "Directory listing for /") with links to any of the five agent folders | T1213 |
Suppress authorized internal scanners with explicit /32 entries, not broad subnet exceptions.
How the other rules work
The KQL hunt has a 14-day lookback and five branches. Two branches catch a file server started from a home folder without a loopback bind. One joins Linux auditd command and working-directory records; the other reads a served-directory argument from Defender process events.
The third branch flags agent or web processes writing compaction, trajectory, backup or auth files. The fourth flags an agent process running a metadata query, a socket import, a DevTools listing or /dev/tcp/. The fifth flags public inbound connections to Python, Node or miniserve on the ad-hoc ports listed in Chapter 2.
The query excludes approved build hosts through two placeholder names. Replace them with your own host names before running it.
The Sigma rules need Sysmon for Linux or auditd process events with the working directory, plus reverse-proxy access logs.
Each YARA rule is limited to files under 20 MB. The four rules matched all 12 synthetic positive samples and none of 4 negative samples in a test of their logic. 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.
How to sort an event
| What the event shows | Action |
|---|---|
A file server bound only to 127.0.0.1 or ::1 | Ignore, local development |
A path under /.hermes/skills/, node_modules/, a test file or SKILL.md | Compare with the upstream package; rotate any key that differs |
| A single-agent session or credential file exposed | Rotate keys and fix the exposure |
| Several agents co-hosted with shared keys | Rotate keys and audit every agent folder |
| Compaction files, metadata probes or reverse shell strings | Investigate as a priority |
| A low-signal workspace file only | Hold for review |
10. Indicators
This report publishes no indicators. All 112 servers are exposed developer or operator machines, and their owners are the victims of the leak. Publishing their addresses, ports, usernames, project names or file names would help others harvest the same credentials.
The secret values are withheld in every form, including their hashes. Defenders should hunt with the path patterns in Chapters 2 to 6 and the rules in the Detection rules tab, and check their own keys against their own agent folders.
11. Scope and Limits
- Window. The findings come from a two-week observation window ending 18 November 2026. Some servers also have earlier directory listings; those listings are used only for counts and are not dated in this report.
- Matches are not confirmed leaks. The 3,145 matches still include some vendor bundle and source code matches. The validity of the exposed credentials was not tested.
- Ownership is unknown. The three hypotheses in Chapter 7 are a working model. Exposed files show server state, not who owns the server.
- C2-pattern strings are not attacks. URLs and shell strings in session logs show what an agent discussed or ran. They do not confirm a breach of any third party.
- No AI vendor was breached. These are files on user-run servers, exposed by the users' own file servers.
- 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.
12. Sources
- Anthropic. Claude Code documentation: session storage, memory and subagents. https://docs.anthropic.com/en/docs/claude-code/overview (verified 18 November 2026)
- OpenAI. Codex CLI repository: configuration, authentication and rollout logs. https://github.com/openai/codex (verified 18 November 2026)
- Cursor. Model Context Protocol documentation. https://cursor.com/docs/mcp (verified 18 November 2026)
- Nous Research. Hermes Agent repository. https://github.com/NousResearch/hermes-agent (verified 18 November 2026)
- OpenClaw Project. OpenClaw repository. https://github.com/openclaw/openclaw (verified 18 November 2026)
- MITRE ATT&CK. T1552.001 Unsecured Credentials: Credentials In Files. https://attack.mitre.org/techniques/T1552/001/ (verified 18 November 2026)
- MITRE ATT&CK. T1213 Data from Information Repositories. https://attack.mitre.org/techniques/T1213/ (verified 18 November 2026)
- Python Software Foundation.
http.serverdocumentation and security warning. https://docs.python.org/3/library/http.server.html (verified 18 November 2026) - F5 Nginx.
ngx_http_autoindex_moduledocumentation. https://nginx.org/en/docs/http/ngx_http_autoindex_module.html (verified 18 November 2026)
What is…?
Short explanations of the tools and families named in this study.
What is OpenClaw?
OpenClaw is an open-source autonomous agent gateway that keeps trajectories, auth profiles and session logs on disk.
More about OpenClawAI agentWhat is Claude Code?
Claude Code is Anthropic's command-line coding agent. It stores project sessions and settings in a .claude folder.
More about Claude CodeAI agentWhat is Hermes Agent?
Hermes Agent is an open-source autonomous AI agent from Nous Research. It keeps sessions, profiles, skills and scheduled jobs in a .hermes folder.
More about Hermes AgentFrequently asked questions
How does a private agent session become public?
Developers increasingly run AI coding agents on rented Linux servers instead of laptops. They paste keys and database URLs into the conversation so the agent can work. The agent saves everything to hidden folders such as ~/.claude/ or ~/.codex/.
Why doesn't deleting the key fix it?
Agents do not keep secrets in one place. They spread them across four layers on disk. The first layer is the main session log, which records every prompt and tool output. The second is a set of helper "subagents". When a conversation gets too long, Claude Code writes a summary of it to a new file, and the keys carry over into that summary. The third layer captures shell commands and their output.
What kinds of secrets leak?
Excluding bundled examples, the servers held 3,145 secret and session matches. AI model keys lead with 919 matches, mostly DeepSeek, Stability AI, Anthropic, OpenRouter and OpenAI. URLs that look like command-and-control or callback endpoints come next at 553. Many of these are webhooks or test endpoints, not proof of attacker infrastructure.
Why do some servers run several agents?
Of the 112 servers, 26 (23.2%) run two or three agents in the same account. A common pattern is a developer using Claude Code or Codex to build and manage a background OpenClaw or Hermes bot.
Are these servers run by attackers?
Mostly not. Our analysis weighed three explanations, as a working model. Of the 112, 83 servers (74.1%) look like developer machines exposed by mistake. Another 21 (18.8%) look like multi-agent build or red-team labs. Eight (7.1%) hold session logs with dense callback URLs, cloud metadata queries or a reverse shell string.
What about indicators?
This report publishes no indicators. Every server is an exposed developer or operator machine, and publishing addresses, file names or key hashes would help others harvest the same secrets. Hunt with the folder paths and the detection rules instead.