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 10 / 1918 min read

When AI Agents Leak Their Own Memory: 112 Exposed Session Servers

How .claude, .codex, .cursor, .openclaw and .hermes folders turn open file servers into credential leaks

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

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.

1

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.

2

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.

3

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

  1. 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.
  2. 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.
  3. 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

NumberWhat it is
112Servers exposing hidden AI agent folders over HTTP; 100 of them hold real user files
3,145Secret and session matches, excluding bundled skill documentation (some vendor source matches remain)
695User session, subagent, tool and credential file paths
26 (23.2%)Servers running two (20) or three (6) AI agent stacks side by side
919 / 553AI 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:

AgentHidden folderWhat 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.

AgentMatchesServers (with user files)
Claude Code98826 (25)
Hermes Agent96775 (58)
OpenClaw93221 (19)
Cursor IDE1846 (3)
OpenAI Codex CLI7416 (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.

Figure 1: Autonomous coding agents split their working memory across four disk layers
Figure 1: Autonomous coding agents split their working memory across four disk layers
LayerPathsWhat it holdsExample files
Primary session209Full conversation: prompts, pasted .env blocks, MCP parameters, raw tool output/.claude/projects/<slug>/<uuid>.jsonl, .trajectory.jsonl, rollout-*.jsonl
Compaction and side-query subagents26 (12 compaction, 14 side-query and task)Summaries written when the context window fills, and parallel side questionssubagents/agent-acompact-*.jsonl, agent-aside_question-*.jsonl
Tool execution58Shell commands, metadata queries, MCP database calls and their outputshell_snapshots/*.sh, tool-results/*.txt
Persistent credential and backup stores402 (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.

PortServersShare of 112
80804439.3%
8888119.8%
8000108.9%
889998.0%
8054.5%
9999 (4), 8081 (4), 18080 (3), 4000 (2), 19999 (2)15
Other high ports, such as 3000, 3003, 8090, 8091, 9090, 912318

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.

Figure 2: Five agent runtimes map distinct dotfiles to cloud and C2 credentials
Figure 2: Five agent runtimes map distinct dotfiles to cloud and C2 credentials

The categories

The 3,145 matches cover 34 secret types, grouped below. Some vendor source matches are still inside these counts.

CategoryMatchesShareLeading types
AI model keys91929.2%DeepSeek (425), Stability AI (204), Anthropic (110), OpenRouter (102), OpenAI (72)
C2 and callback URLs55317.6%C2-pattern endpoints (550), reverse shell strings (3)
Generic passwords and secrets37411.9%Passwords (195), generic secrets (179)
Database and SaaS35711.4%Airtable keys (266), database connection strings (91)
Bot and drop channels35311.2%Telegram bot tokens (285), Discord bot tokens (42), out-of-band callbacks (16), Pastebin drops (10)
Cloud and mesh access2518.0%Google API keys (115), GCP OAuth secrets (67), DigitalOcean tokens (48), Vultr keys (14), GCP application default credentials (2)
Crypto and SSH keys2156.8%Private keys (98), Tailscale keys (48), JWTs (45), BIP-39 seed phrases (23)
Source control1113.5%GitHub tokens (90), GitHub personal access tokens (21)
Exchange and monitoring120.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:

SecretCountNote
PEM private keysUp to 6898 matches minus 30 that are regex patterns inside redact.py source code; not yet checked for other bundle rows
GitHub tokens111Source code and CI access
GCP OAuth secrets67Cloud project access
DigitalOcean tokens48Droplet and account control
Tailscale keys48Entry into a private mesh network
Telegram and Discord bot tokens327Control 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

LayerPath pattern under /.claude/Present onRole and secrets
OAuth store.credentials.jsonHost AClaude OAuth access token, refresh token and scopes
Pre-edit file historyfile-history/<session>/<snapshot>@v2, @v3BothVersioned copies of scripts before secrets were removed
Primary sessionsprojects/<slug>/<uuid>.jsonl (three sessions; a fourth on Host B)BothFull transcripts with Anthropic, OpenAI and Telegram keys
Compaction subagentsprojects/<slug>/<uuid>/subagents/agent-acompact-*.jsonl (six files)BothSummaries that concentrate GCP OAuth, DigitalOcean, GitHub and Tailscale keys
Side-query workers.../subagents/agent-aside_question-*.jsonl (two files)BothSide questions saved to disk next to the parent session's tokens
Memory noteprojects/<slug>/memory/*.mdBothA 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.

Figure 3: Context compaction and backup sprawl preserve secrets before HTTP exposure
Figure 3: Context compaction and backup sprawl preserve secrets before HTTP exposure

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:

FileWhat it holds
/.codex/auth.jsonBearer tokens
/.codex/agentrouter.envCustom router keys
/.codex/config.tomlProvider keys in TOML, including a DeepSeek key on one server
/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonlDate-sharded session logs
/.codex/shell_snapshots/*.shSaved 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 serverServersShare
One8676.8%
Two2017.9%
Three65.4%

Which agents run together

StackServersShare of 112Example serverMatches and notes
Hermes + OpenClaw65.4%Host C, German VPS183 matches in 285 files; the same Anthropic and Discord keys in two agents, IMDS query, reverse shell string
Claude + Codex54.5%Host B, European VPS254 matches; copied Claude subagent tree, Codex in the same home, 67 C2-pattern URLs
Claude + OpenClaw32.7%US VPS70 matches; three custom OpenClaw personas and plugin catalogs
Claude + Hermes + OpenClaw21.8%Host E, Asia-Pacific VPS156 matches; Claude memory note about OpenClaw bots, 88 C2-pattern URLs
Claude + Codex + OpenClaw21.8%Host G, Asia-Pacific VPS97 matches; the same DeepSeek key in a Codex rollout and an OpenClaw script
Codex + Hermes21.8%European VPS59 matches; /.codex/auth.json next to Hermes profile .env files
Claude + Hermes21.8%Asia-Pacific VPS25 matches; Claude project history next to Hermes config backups
Claude + Codex + Cursor10.9%Host F, Chinese VPS125 matches in 116 files; remote Cursor and VS Code IDE, Claude MCP and Codex CLI
Cursor + Hermes, Codex + Cursor, Claude + Codex + Hermes32.7%Three servers8 to 17 matches each; remote Cursor SSH server next to CLI agents
Figure 4: Nearly one quarter of exposed session servers co-host multiple AI runtimes
Figure 4: Nearly one quarter of exposed session servers co-host multiple AI runtimes

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/:

SourceValuesWhat they are
ComfyUI skill reference16Local 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 files4Placeholders in SKILL.md, backends.md and a skills backup archive
Hermes session log11One 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.

HypothesisServersWhat supports itResponse
H1: Developer or AI engineering server exposed by mistake83 (74.1%)Single-agent installs serving SaaS, trading or study projects through an ad-hoc http.serverFix the exposure and rotate keys; do not block permanently
H2: Multi-agent builder or red-team lab21 (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 URLsCheck corporate egress for accidental tunnel use; rotate matched keys
H3: Workbench with offensive content8 (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.1 for python3 -m http.server, npx serve and similar tools on engineering hosts. Alert on any launch in /root or /home/ that binds to all interfaces.
  • When rotating a key, also delete subagents/agent-acompact-*.jsonl, file-history/, .jsonl.bak-*, .reset.* and shell_snapshots/ in ~/.claude/, ~/.openclaw/ and ~/.codex/.
  • Replace hard-coded DATABASE_URL values in ~/.cursor/mcp.json and 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: Google header and workload identity on GCP, and use the token-hardened metadata mode on Alibaba ECS. On DigitalOcean and other Linux VPS hosts, block 169.254.169.254 with 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 fileWhat it catches
odin_ai_agent_session_exposure.rulesSuricata 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.kqlMicrosoft 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.ymlSigma (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.yarYARA (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

SIDLooks forATT&CK
9510001GET request for /.claude/.credentials.jsonT1552.001
9510002GET under /.claude/projects/ for a .jsonl file, memory/ or tool-results/T1213
9510003GET for subagents/agent-acompact-*.jsonlT1552.001
9510004GET under /.openclaw/agents/ for .jsonl, auth-profiles.json or models.jsonT1552.001
9510005GET under /.codex/sessions/ for a rollout-*.jsonl fileT1213
9510006GET under /.cursor/ for mcp.json or an agent transcriptT1552.001
9510007GET under /.hermes/ for request dumps, session files, state snapshots or profile auth.json and .env, excluding /skills/T1552.001
9510008HTTP 200 directory listing ("Index of /" or "Directory listing for /") with links to any of the five agent foldersT1213

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 showsAction
A file server bound only to 127.0.0.1 or ::1Ignore, local development
A path under /.hermes/skills/, node_modules/, a test file or SKILL.mdCompare with the upstream package; rotate any key that differs
A single-agent session or credential file exposedRotate keys and fix the exposure
Several agents co-hosted with shared keysRotate keys and audit every agent folder
Compaction files, metadata probes or reverse shell stringsInvestigate as a priority
A low-signal workspace file onlyHold 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

  1. Anthropic. Claude Code documentation: session storage, memory and subagents. https://docs.anthropic.com/en/docs/claude-code/overview (verified 18 November 2026)
  2. OpenAI. Codex CLI repository: configuration, authentication and rollout logs. https://github.com/openai/codex (verified 18 November 2026)
  3. Cursor. Model Context Protocol documentation. https://cursor.com/docs/mcp (verified 18 November 2026)
  4. Nous Research. Hermes Agent repository. https://github.com/NousResearch/hermes-agent (verified 18 November 2026)
  5. OpenClaw Project. OpenClaw repository. https://github.com/openclaw/openclaw (verified 18 November 2026)
  6. MITRE ATT&CK. T1552.001 Unsecured Credentials: Credentials In Files. https://attack.mitre.org/techniques/T1552/001/ (verified 18 November 2026)
  7. MITRE ATT&CK. T1213 Data from Information Repositories. https://attack.mitre.org/techniques/T1213/ (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)
  9. F5 Nginx. ngx_http_autoindex_module documentation. 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.

All explanations

Frequently 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.

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_ai_agent_session_exposure.rules 29 lines
Download
YARA odin_exposed_ai_agent_session_artifacts.yar 130 lines
Download
Sentinel KQL sentinel_ai_agent_workspace_exposure_hunt.kql 98 lines
Download
Sigma sigma_exposed_ai_coding_agent_http_serving.yml 119 lines
Download