For a long time, the cybersecurity industry had an unspoken division of labor:
- Automated scanners (DAST/SAST): tools like Acunetix, Burp Suite Scanner, or Nuclei. They're fast and sweep thousands of URLs a minute, but they operate strictly on hardcoded signatures. If a developer tweaks a parameter structure slightly or puts a basic WAF (Web Application Firewall) in front of an endpoint, a dumb scanner gives up and logs a false negative.
- Human pentesters (White/Black Hat): live specialists. They read a stack trace, understand the framework context, spot a subtle leak in a server response, and manually chain together an exploit to slip past quote filters and keyword blacklists.
A recent incident shook up the security research community, though: an independent Chinese researcher published a report on an experiment in which an autonomous LLM-powered agent probed and successfully compromised more than 1,200 websites automatically.
No human operator in the loop. No pre-written exploits tailored to each site. The agent simply took a target domain, kicked off an exploration loop, and worked its way to Remote Code Execution (RCE) or a full database dump on its own.
Let's look at how this mechanism works inside, why traditional defenses fall short, and how developers can protect their services in the era of autonomous attacking agents.
Attacking Agent Architecture: The ReAct Loop
At the heart of the system is the ReAct (Reasoning + Acting) pattern paired with a suite of system tools (Function Calling / Tool Use).
Architectural cutaway of the Swift compiler on Linux: interaction between the Wasmtime WebAssembly runtime and the WASI system call interface.
The agent is built from four core modules:
- Reconnaissance Engine: autonomously crawls site links, maps endpoints, and hunts down input forms, hidden API routes,
.gitfolders, backup archives, and forgotten.envconfig files. - LLM Reasoner: a language model with a large context window whose system prompt encodes vulnerability analysis principles based on the OWASP Top 10.
- Toolbox: a set of utilities the agent can invoke directly via a terminal—curl, nmap, sqlmap, a headless Chromium browser, parameter fuzzers, and a Python interpreter.
- Feedback & Reflection Loop: the critical piece that separates a ReAct agent from an ordinary script.
The Iterative Feedback Loop: Why WAFs Struggle
A classic vulnerability scanner operates on a "fire and forget" model: it sends ' OR 1=1 --, gets a 403 Forbidden back from Cloudflare WAF, and moves on.
An autonomous agent acts like a patient human attacker:
- Probing: the agent sends a baseline request and inspects the response body, headers, and HTTP status.
- Response analysis: did the server return an error with a Jinja2 or Django stack trace? The agent immediately deduces: "This is a Python stack using Jinja2; Server-Side Template Injection (SSTI) might be on the table."
- WAF Bypass: the agent tries sending a test payload like
{{7*7}}. The WAF blocks the request because of the curly braces. The agent sees the WAF response code, analyzes which token got flagged, and crafts an alternative payload—hex string concatenation, Jinja2attr()filter bypasses, or alternate template tags. - Locking in the win: as soon as the expression evaluates to
49, the agent knows the injection worked and deploys a full payload to read server files or open a reverse shell.
The agent has infinite patience: it can fire off 50 sequential micro-requests mutating parameters until it finds a crack in the application's logic. We also explored how scenarios like this are evolving in our study on the anatomy of AI agent intrusions and security risks.
The Most Common Weaknesses: What Tripped Up 1,200 Sites?
Contrary to expectations, the agent wasn't burning zero-day exploits in the Linux kernel or browser engines. The overwhelming majority of the 1,200 compromised targets fell to standard, underestimated web development mistakes:
1. Server-Side Template Injection (SSTI)
Developers still concatenate user input straight into template strings instead of passing variables through a context:
render_template_string("Hello, " + user_input). For an agent, identifying the engine from its error messages and invoking a system shell through built-in Python or Node.js object methods takes seconds.
2. Insecure Deserialization
Relying on unsafe serialization libraries (Python's pickle, unvalidated JSON.parse with custom revivers in JS, vulnerable gadget chains in Java). The agent spots serialized cookies or hidden form fields and generates platform-specific exploit objects.
3. Leaked Configs and Debug Endpoints
Forgotten /.env files, /.git/config, Spring Boot's /actuator/heapdump, or unauthenticated Swagger UI endpoints. The agent automatically pulls memory dumps and parses out database passwords and cloud API tokens.
4. Blind SQL Injection in Filters and Headers
Plenty of developers sanitize parameters in POST bodies while forgetting X-Forwarded-For, User-Agent, or ORDER BY sorting parameters. The agent detects time delays (Time-Based Blind) and extracts admin password hashes character by character.
What This Changes for Engineers—and How to Defend
The biggest tectonic shift is that "Security through Obscurity" is officially dead. You used to be able to hope nobody would find an internal portal at stage-portal-beta.corp.local because human pentesters wouldn't bother and automated scanners couldn't get past an awkward login form.
For autonomous ReAct agents, form complexity or non-standard routes are no longer a barrier. They can solve basic challenges, click buttons via Playwright, guess valid field values from input names, and read frontend JavaScript bundles.
What you should do right now:
- Parameterize everything: eliminate string concatenation in SQL queries, shell commands, and template engines. Stick strictly to prepared statements and explicit context passing.
- Least privilege for processes: never run a web server as root. Lock down disk access at the container level with
readOnlyRootFilesystem: true. - Disable stack traces in production: error tracebacks should never leave the server. To an agent, a stack trace is a roadmap with file paths, library versions, and line numbers.
- Behavioral anomaly detection: if a client sends dozens of requests gradually mutating special characters and timing parameters, that's a telltale sign of an adaptive agent. Traditional WAFs need to be paired with behavioral analysis across request sequences.
The era when attackers needed weeks of manual reverse engineering has given way to autonomous machines. The only reliable defense left is strict architectural code hygiene.

![Node.JS [ru]](/api/digests/it_development/daily/20261022/assets/sources/we-use-js.jpg?v=a0f44cd5adea38f5565ca34efcbf68f295fb7e34338ebf79f7f36277e0148001)
