- I pointed an autonomous offensive agent at Holo (TryHackMe, Hard): exposed web app, container breakout, pivot into the internal network, foothold in Active Directory, local admin on the file server. A whole attack chain, built and chained by the agent without me touching the keyboard.
- Then, at the last hop (the NTLM relay to the Domain Controller), the agent loaded the weapon, aimed it… and sat down to wait for a shot that never came.
- This piece is about that boundary: not where an agent succeeds, but where it stops succeeding. Which is the only interesting part. One run only: it is a case study, not a statistic (section [05]).
[00] The setup, or: why torture an agent
There is a literary genre in security that everyone is sick of: the "I owned the DC" writeup. You open it, scroll through twenty mimikatz screenshots, reach the bottom, there's the flag, standing ovation. There are thousands of them. Their average information value tends to zero, because they all tell the same story with the same tools in the same order.
This is not one of those. The question here is not "can Holo be done?": yes, it can, it is a training room with an intentional kill chain. The question is: if I take an autonomous offensive agent and let it loose on a realistic AD network, how far does it get on its own? And above all, where does it get stuck, and why?
Because that is where the research is. The marketing of offensive agents is at shopping-channel level ("the AI that hacks everything!"). Reality, when you measure it, is much more sober and much more useful: an agent is a strange beast, brilliant in some phases, blind in others, and its breaking point tells you more about the future of the job than any flag.
Rules of engagement. Authorized target: a TryHackMe lab, isolated network, only the addresses assigned to my instance. The agent runs in my lab, with a harness that gives it a shell, session memory and the ability to write and run its own tools. No writeup fed in, no hints, no "psst, try the DLL hijack". I watch. Sometimes with my head in my hands. It is a personal test, run on my own account: a practitioner's curiosity, not a benchmark.
And no, I'm not telling you which harness it is.
[01] The target: Holo
For those who don't know it: Holo is one of TryHackMe's Hard networks (premium), built by the platform's own team. It simulates an external penetration test against a fictional company and touches pretty much every bad thing:
- misconfigured subdomains, LFI, RCE on web apps;
- Docker container breakout;
- SUID and Linux privesc;
- pivoting into an internal network;
- password reset logic flaws and client-side filter bypasses;
- AV/AMSI evasion, AppLocker bypass;
- vulnerable DLLs and, grand finale, a remote Net-NTLM relay to the Domain Controller.
In other words: the path is not a CTF trick, it is a sequence of plausible mistakes like the ones you really find in production. Exactly the kind of ground where I want to see how an agent moves.
The topology, roughly:
[ Internet ]
│
▼
L-SRV01 ── exposed web app (LFI → RCE) ───┐
│ └── Docker container (breakout, SUID) │ DMZ
▼ │
internal network ───────────────────────────┘
│
├── S-SRV01 ── internal web: password reset + upload bypass → SYSTEM
├── PC-FILESRV01 ── pass-the-hash → AppLocker bypass → DLL hijack → admin
├── S-SRV02 ── (the client the authentication was expected from… spoiler: it never came)
└── DC-SRV01 ── Domain Controller, the end-of-level boss[02] The chain, phase by phase
For each phase I describe what the agent did and, because it is the part nobody writes, what a defender would have seen. The conditional is deliberate: inside TryHackMe I don't have the target machines' logs, so the defensive column is what well-configured telemetry would record, not what I measured. If your only metric is "how many flags", this second column is the reason your SOC exists.
A note on hygiene: flags, hashes and credentials are redacted (HOLO{…}, [redacted]), and the details you would need to redo the room step by step are left out. The point, quoting my own CTF disclaimer, is how you get there, not the value.
Phase 0 — Recon
The agent starts like anyone does: it enumerates the external surface, finds the web app, maps the subdomains. Nothing epic. What is interesting is the way: it didn't follow a human checklist, it ran scans, read the output, reformulated its hypotheses and narrowed the field on its own. The first time you see it correlate a robots.txt with a development subdomain and decide by itself where to dig, it's quite something.
What a defender would have seen: a single IP touching hundreds of paths and vhosts in a few minutes. Scanner noise, pure and simple: web server access logs, a spike of 404s, tool user agents. Detectable with your eyes closed, if someone is looking.
Phase 1 — Web: from WordPress to shell
The exposed web app runs on a WordPress that has seen better days. The agent finds a Local File Inclusion on a subdomain, uses it to read a file with credentials left where it shouldn't be, and from there moves to an RCE on another part of the site. Shell as www-data. Welcome to L-SRV01.
What struck me: the agent treated the LFI not as the goal but as a way to gather information (read config files, find the leak), then switched vector for execution. Multi-hop reasoning, not "fire exploits at random".
What a defender would have seen: requests with path traversal patterns (../), parameters pointing at /etc/…, and then a request that makes the web server start a child process. *A www-data starting /bin/sh is, in production, the moment everything should go off.*
Phase 2 — Container breakout
Surprise: the shell is inside a Docker container, not on the host. The agent notices (the classic clues: .dockerenv, cgroups, network), then enumerates the way out. It finds an exploitable SUID binary and gets root on the host.
An honest note on the agent's behavior here, which I'll come back to in the self-critique: in the privesc phase the agent spent quite a lot of time on roads that led nowhere before converging on the right one. An experienced human would have looked at the SUIDs first. The agent got there, but by exhaustion more than by intuition.
What a defender would have seen: execution of a SUID binary in an unusual context, followed by brand-new root activity. Runtime monitoring on Linux (auditd, Falco) has an easy job here, if configured: and that "if" is the size of a house.
Phase 3 — The pivot
Root on L-SRV01, the agent discovers the internal network, out of direct reach. It sets up a tunnel, builds itself a bridge inside and starts scanning again from within. From here on we are in Active Directory territory, and this is where Holo stops joking.
What a defender would have seen: tunneling traffic (a "strange" port carrying a lot, long sessions to a DMZ host), and a border host that suddenly talks to the whole internal subnet. Segmentation and netflow are your friends. If you have them.
Phase 4 — S-SRV01: logic that breaks
On the internal network there is a web app with a badly built password reset. The agent works out how to get a valid token, and combines it with a client-side upload filter bypass to upload a web shell. Then, to run payloads on Windows, it has to get past AMSI and Windows Defender: the agent generates a bypass, obfuscates it, and gets code execution. From web shell to SYSTEM, and from SYSTEM to a credential dump: out comes a domain user ([redacted]).
This is the phase where the agent surprised me most. The chain password reset → upload bypass → AMSI bypass → execution is not obvious, it has four links chained with different logic, and it tied them together on its own.
What a defender would have seen: a string of signals that, in isolation, look like nothing and, in sequence, are a horror film: repeated resets close together on the same user, uploads with the "right" extension but the wrong content, and above all the post-bypass PowerShell. Here real detection is not the single rule, it is correlation. And that is exactly the gap attackers live in.
Phase 5 — PC-FILESRV01: pass-the-hash and DLL hijack
With the domain credentials, the agent does pass-the-hash to the file server PC-FILESRV01 and gets in. The server has AppLocker on: the agent gets around it through paths the policy forgets to cover (the great classic, AppLocker configured "almost right"). Then it spots an application vulnerable to DLL hijacking, which looks for a missing DLL in a writable path, plants its own DLL and gets admin/SYSTEM on the file server. Dump of LSASS, SAM and cached credentials.
What a defender would have seen: an NTLM network logon where you would expect Kerberos, a process started from a folder that AppLocker lets through but that a user can write to, and an unsigned DLL loaded from a user directory. Sysmon Event ID 11 (file created) followed by Event ID 7 (image loaded) tells the whole story. Again: if someone collects them.
Phase 6 — The Domain Controller, and the wall
And here we get to the point of the piece.
Holo's last hop is every red teamer's north star: a remote NTLM relay from PC-FILESRV01 to DC-SRV01. The idea: wait for another internal host (S-SRV02) to authenticate, intercept that Net-NTLM session and relay it to the Domain Controller to get domain privileges. The agent did its homework: it set up the relay, the port forward and the proxy, and aimed everything at the DC. The weapon was assembled, loaded and aimed.
Then it sat there, waiting for an inbound SMB connection that, as far as I could see, never came. I don't know the reason for sure: maybe in this instance the scenario's client didn't authenticate, or maybe something in the agent's chain (listener, forwarding, filters) wasn't right. Without the run's and the target's logs I can't tell the two apart. The agent waited, checked the configuration, retried, checked again. Operationally: zero.
And this is the interesting part, not the flag that isn't there.
[03] What it really tells us about offensive agents
Strip the piece of everything else and this is what's left: in this run the agent was very strong where the problem was "find the chain and build it", and weak where the problem was "make something happen in the world and wait".
Think about where it shone: correlating a leak with a vector, chaining four bugs with different logic, writing itself an AMSI bypass, recognizing a container and finding the way out. All of it is reasoning over observable state. The agent reads, hypothesizes, acts, reads again. In that loop it is good, at times more patient and systematic than a human (it doesn't get bored, it doesn't skip steps because "I know this anyway").
And think about where it got stuck:
- The world doesn't respond on command. The relay needs someone else to authenticate. It is not a bug to execute, it is a condition to trigger or wait for. The agent behaved as if it had no robust model of "I've done my part, now it depends on an external actor with its own timing": it treated waiting as a problem to solve right away, not as a legitimate state.
- Privesc by exhaustion, not intuition. In Phase 2 it got there, but by trying many dead ends. An experienced operator "feels" where to look. The agent doesn't: it makes up for it with systematic brute force. That works as long as the search space is small.
- No instinct for "when to stop and change approach". Facing the DC wall, a human red teamer would, after a while, have changed strategy: trigger the authentication instead of waiting for it (coercion techniques have been known for years), or look for another path through the domain. The agent kept polishing the same solution instead of changing road.
So the thesis is uncomfortable for the enthusiasts and reassuring for defenders: today's offensive agents compress a lot of the time spent on the "reasoning" phases of an attack, but they don't eliminate the red teamer: they shift their value toward judgment, timing and knowing when plan A is dead. The "junior who never sleeps" already exists. The senior who decides doesn't. Not yet. It is an opinion built on a single run, and I treat it as such in section [05].
And there is a defensive corollary that matters to me, because it is the direction of my research: if the agent-attacker works in tight observe-act-observe loops, then it might leave dense, rhythmic telemetry, different from a human's. It is a hypothesis, not a result of this run: I didn't measure the cadence here. The agent isn't quiet, it's fast. And speed, if you are recording it, is a signal.
[04] Detection, in a table
Because a writeup without the defensive column is half the job.
| Phase | Offensive action | Where it shows (if you look) |
|---|---|---|
| 0 | Surface recon | 404 spike / vhost fuzzing, tool UA in the access logs |
| 1 | LFI → RCE on WordPress | Path traversal in parameters; www-data → /bin/sh |
| 2 | Container breakout, SUID | Unusual SUID exec, brand-new root (auditd/Falco) |
| 3 | Internal pivot | Tunneling on an unusual port, DMZ host talking to the whole subnet |
| 4 | Password reset + upload + AMSI bypass | Resets close together, upload whose content doesn't match the extension, post-bypass PowerShell (correlation!) |
| 5 | PtH + AppLocker bypass + DLL hijack | Unusual NTLM logon (4624 type 3), exec from an allowed writable folder, Sysmon 11 → 7 on an unsigned DLL |
| 6 | NTLM relay → DC | Authentications from an IP that doesn't match the host, SMB signing not required, proxy sessions to the DC |
The table is the map of the detection opportunities (to be validated, not measured in this run); below is the real detection engineering, phase by phase, in the format I would use in an assessment. All on the defense side: no payloads, only how you catch it.
Phase 1 — web → shell. The signal is not the LFI (too many false positives on ../), it is the process genealogy: a web server spawning a shell. On Linux, an auditd/Falco rule on execve with a parent in the set of web servers (the same logic applies to IIS on Windows):
# Sigma (pseudo) — web server spawns shell
parent_image in ['httpd','apache2','php-fpm','nginx','w3wp.exe']
and child_image in ['sh','bash','dash','nc','ncat','python','powershell.exe']
→ HIGHA www-data that is the parent of /bin/sh almost never has a legitimate explanation.
Phase 2 — container breakout. Falco has default rules for some escape primitives (for example Change thread namespace); others, such as running SUID binaries outside the baseline, have to be enabled or written, and often sit in rule sets that are not active by default. Rule names and status change from one version of falcosecurity/rules to the next: check the one you use. The question to ask in an audit is not "do I have Falco", it is "does anyone read the Falco alerts". (Typical answer: no.)
Phase 4 — AMSI bypass. This is the richest point on the Windows side. Three levels:
- Event ID 4104 (PowerShell Script Block Logging, in the Microsoft-Windows-PowerShell/Operational log) with the known signatures of AMSI bypasses: references to
AmsiUtils,amsiInitFailed, reflection onSystem.Management.Automation. Public Sigma rules already cover the best-known variants; a well-obfuscated bypass avoids them, but the script block is logged after decoding, and the obfuscation itself is a signal. - Defender Event ID 1116/1117 (threat detected / action taken, in the Microsoft-Windows-Windows Defender/Operational log) if the obfuscation isn't perfect.
- Parent-child correlation:
powershell.exewith a parent process ofw3wp.exe/php-cgi.exe. In KQL on Microsoft Defender for Endpoint / Sentinel:
DeviceProcessEvents
| where InitiatingProcessFileName in~ ("w3wp.exe","php-cgi.exe","httpd.exe")
| where FileName in~ ("powershell.exe","pwsh.exe","cmd.exe")
| project Timestamp, DeviceName, InitiatingProcessFileName, FileName, ProcessCommandLineA web server launching PowerShell is, in production, guilty until proven innocent.
Phase 5 — pass-the-hash + DLL hijack. Three signals:
- PtH: on the destination host, Event ID 4624 Logon Type 3 with the NTLM authentication package for an account that usually uses Kerberos; on the DC, for domain accounts, NTLM validation (4776) without the Kerberos ticket requests (4768/4769) a normal logon would produce. NTLM on its own is common; the signal is NTLM where you don't expect it. You need to correlate the host's logs with the DC's.
- DLL hijack: Sysmon Event ID 11 (file created) for a DLL in a user-writable directory, followed by Event ID 7 (image loaded) of the same unsigned DLL, in a process that normally loads signed system DLLs. Event ID 7 is noisy and in many configurations is off or filtered: turn it on selectively, for example for unsigned DLLs loaded from user paths.
- AppLocker: events 8003 (in audit mode: "would have been blocked") and 8004 (in enforce mode: "blocked") record what the policy would stop. But a bypass through a path the policy allows produces neither: for that you need process creation (Sysmon 1 or 4688) from allowed but user-writable folders. Keeping audit on even where you don't enforce is still useful to find the holes in the policy before an attacker does.
Phase 6 — NTLM relay. If the relay targets an SMB service, the precondition is that the target doesn't require SMB signing: a periodic scan that flags hosts with signing not required is prevention at almost zero cost. A relay to other services (for example LDAP) depends on different protections, such as LDAP signing and channel binding, and mandatory SMB signing doesn't stop it. A signal worth investigating is the authentication that doesn't add up: an account authenticating to the DC (4624 with NTLM) from an IP address that doesn't match the declared workstation. On its own it doesn't prove a relay, because NAT, VPNs and legitimate proxies produce the same mismatch: you need an up-to-date inventory of hosts and addresses, with the network exceptions. It can be done with a rule that checks the inventory or with UEBA; without an inventory, neither of them sees it.
And here is the part that interests me as research. All these signatures assume a human attacker. But an agent works in tight observe → act → observe loops, and my hypothesis is that it has a different cadence: more regular inter-arrival times between actions, fewer "human" pauses, enumeration bursts at an almost constant rate. It wouldn't be a classic indicator of compromise, but an indicator of automation. The thesis I am working on is that an agent-attacker's telemetry has a timing signature that can be told apart from a flesh-and-blood operator's, and that it could become a detection signal of its own. Holo doesn't prove it: in this run I measured neither timing nor the target's telemetry. It is the starting point for the next experiment, which has to run in a lab of my own, with telemetry on and a comparison with human operators.
If your organization has even half of this covered and correlated, you have a good chance of seeing an attacker like this. These are detection opportunities to validate in your environment, not guarantees: and phase 6, which didn't land here, might not leave the relay signal at all. The problem, in my experience as a consultant, is rarely that companies can't see it. It is that nobody looks at the logs until it is too late. Would your logs have caught it?
[05] Limitations and self-critique
A fixed section of this blog, and here it weighs more than usual. Intellectual honesty > epic.
- The DC was not compromised in this run. The chain stopped at the armed relay, waiting for an authentication that didn't come. I can't say for sure whether the scenario's condition was missing or the agent's setup had a flaw: the agent's configuration and the client's behavior were not verified independently. I'm not claiming a full compromise that didn't happen. Changing road, i.e. forcing the authentication instead of waiting for it or looking for an alternative path through the domain, is precisely the "senior who decides" move the agent lacked on its own: the theme of the whole piece, not a footnote.
- One run only, result not fully deterministic. Lab instances vary, and the agent's behavior is sensitive to the observed state and to the model. A second run might get stuck somewhere else or get past exactly this point. A single run is an anecdote, not a statistic: I treat it as such.
- The defensive column is not measured. On TryHackMe I have no access to the target machines' logs: "what a defender would have seen" describes what well-configured telemetry would record, not what I observed. The idea of an agent cadence is a hypothesis too, not a result.
- Harness not named. Readers can't redo the run with the same tool: the conclusions hold for this agent, not for "agents" in general.
- Lab, not production. Holo is a training environment with an intentional path. An agent-attacker against a real, noisy, defended network is another beast. The conclusions about the shape of agentic behavior hold; the absolute timings don't.
- Attributing the phases. Where the agent "reasons" and where it simply exhausts the search space can't always be told apart from the outside. I flagged the cases where the difference was visible; elsewhere I avoided anthropomorphizing.
[06] Reproducibility and hygiene
- No flags, hashes or credentials in clear, and no walkthrough details (versions, file names, accounts, commands): out of respect for the people who built the room, and common sense.
- There are no transcript or tool-output excerpts in the post: the phases are described at the level of methodology.
- Tooling is mentioned at the level of methodology, not as ready-to-paste code: the value is the reasoning, not the script.
[07] Moral
The moral, if one is needed: this offensive agent, in 2026, is a tireless junior who is brilliant at chaining, and who gets stuck at the exact moment an operator would need to decide that plan A is dead. Good news for defenders, bad news for anyone selling "the AI that hacks on its own". And, by the way, almost every phase of this chain offered a chance to see it: most of the time the problem isn't seeing the attack. It's looking.
Sources
- TryHackMe, Holo (network, premium) — tryhackme.com/room/hololive
- TryHackMe, Acceptable Use Policy, version 2.0 (28 August 2026), §8 and §9 — tryhackme.com
- Microsoft, about_Logging_Windows (Script Block Logging, Event ID 4104) — learn.microsoft.com
- Microsoft, Event 4624 (an account was successfully logged on) — learn.microsoft.com; Event 4776 — learn.microsoft.com
- Microsoft, Using Event Viewer with AppLocker (events 8003, 8004) — learn.microsoft.com
- Microsoft, Microsoft Defender Antivirus event IDs (1116, 1117) — learn.microsoft.com
- Microsoft, DeviceProcessEvents table (advanced hunting) — learn.microsoft.com
- Microsoft Sysinternals, Sysmon (events 1, 7, 11) — learn.microsoft.com
- Falco, rules repository — github.com/falcosecurity/rules; SigmaHQ — github.com/SigmaHQ/sigma