A solo researcher, armed with a team of AI Agents, autonomously breached three major US manufacturers: John Deere, SharkNinja, and Cummins.
The Verge's report reconstructs the operation in detail. It also reached the front page of Hacker News (discussion thread).
Here is how it worked.
How One Person Used Agents to Breach Three Companies
The key was not a single Agent running the entire attack chain. The operation relied on multiple Agents working together.
An orchestrator assigned tasks, with each Agent playing a specific role:
- Reconnaissance Agent: Ran OSINT, scanned subdomains, reviewed leaked documents, and built LinkedIn profiles of employees
- Exploitation Agent: Queried CVE databases based on reconnaissance results, generated proof-of-concept exploits, and wrote exploit code
- Lateral Movement Agent: After gaining an initial foothold, found internal pivots, escalated privileges, and moved across the network
- Reporting Agent: Compiled the intrusion artifacts, commands, and screenshots into a readable report
The Agents communicated through shared memory and task queues. Each stage consumed the output of the stage before it.
The difference from conventional automation appeared in the middle of the chain. The exploitation Agent did not simply “mechanically execute” a payload. It examined errors from failed exploits, inspected stack traces, modified the payload, and retried. This kind of adaptive retry is largely absent from traditional scripts.
Consider a proof-of-concept for a CVE that returned GLIBC version mismatch on the target machine. A conventional script would simply fail. The Agent would run cat /etc/os-release and search for a compatible version.
Why These Three: Farm Equipment, Consumer Appliances, and Diesel Engines
The targets were not chosen at random. All three represent traditional manufacturers where the boundaries between OT and IT have blurred:
- John Deere: Its agricultural equipment includes many connected devices for precision farming and remote diagnostics, while older systems still contain hard-coded credentials
- SharkNinja: Its consumer appliances and IoT products depend on a supply chain that includes contract manufacturers and third-party components
- Cummins: Its diesel engines and industrial control systems often operate on patching cycles measured in years
Internet-focused companies such as SaaS providers and fintech firms have been tested by red teams countless times. Their WAFs, EDR platforms, and SOC pipelines have been refined through years of use.
Traditional manufacturers have not received the same scrutiny. Their security spending has remained low for three reasons:
- Their core business is selling equipment, not managing data
- OT and IT networks have long been isolated, until 5G and industrial internet technology began connecting them
- Compliance provides limited pressure, as frameworks such as SOX and PCI do not directly cover many of these systems
For attackers, these targets offer a much higher return on investment: weaker defenses, valuable assets that can support industrial espionage, and the potential for stealth after a breach.
At its core, Agent-powered red teaming uses systems with a low marginal cost to exploit the weakest side of a target's defenses.
How Agent Red Teams Differ from Traditional Automated Attacks
The ceiling for traditional scripts combined with tools such as Burp Suite is defined by hard-coded logic, fixed payloads, and human interpretation of responses.
LLM Agents break through that ceiling in three ways.
1. Understanding Unstructured Responses
Server returned: "Warning: mysql_connect(): Access denied for user 'admin'@'10.0.0.5'..."
Traditional automation would treat this as a string. An Agent can extract Access denied, the internal IP address 10.0.0.5, and the username admin. It can then infer that the target is internal, may use default credentials, and should be followed by a scan of 10.0.0.0/24.
2. Changing Strategy on the Fly
A conventional script stops when it encounters a WAF block. An Agent can inspect the WAF's block page, identify whether it is running Cloudflare or ModSecurity, switch payload encoding methods, modify request headers, and move to HTTP/2.
3. Reading Error Logs and Writing Fixes
This is the most consequential capability. While debugging its own exploit, an Agent can read a Python or Java traceback, identify the error, patch the code, and run it again. Traditional penetration-testing toolchains have no native ability to repair themselves in this way.
Combined, these capabilities allow Agent red teams to operate one to two orders of magnitude faster than traditional automation, without requiring the attacker to possess deep domain expertise.
Traditional defenses rely on an implicit assumption: attackers are either humans or fixed tools.
- WAFs expect attacks to use known payload patterns
- EDR products expect malware to have signatures or recognizable behaviors
- SOC analysts expect alerts to contain commands written by people
That assumption breaks down when the attacker is a group of autonomous Agents capable of reading PDFs, writing scripts, and calling APIs.
Their malicious behavior resembles that of a diligent junior engineer:
- The commands appear reasonable, including legitimate tools such as
nmap,curl, andgit clone - The timing appears human, with pauses for simulated reasoning rather than machine-speed bursts
- The logs remain readable, without obvious obfuscation
This dilutes the value of SIEM alerts. The Agents do not necessarily bypass a WAF; they leave it uncertain whether traffic should be blocked.
Defenders need to model the behavioral patterns of autonomous Agents, rather than add another isolated detection rule. That capability remains largely undeveloped.
Weaponizing Open-Source Agents: The Next Step After ReAct and AutoGPT
Agent red teaming did not appear suddenly. Researchers have been exploring it for years:
- Anthropic and METR, 2024: Published a joint evaluation of Claude Agents for red teaming, focused on autonomy in long task chains rather than real intrusions
- ReAct, 2022, Princeton: Introduced a foundational framework that couples reasoning and action within an Agent loop
- AutoGPT, 2023: Became the first widely recognized “fully autonomous Agent” project
- PentestGPT, 2023: Developed an Agent specifically for penetration testing, with an open-source implementation on GitHub
The critical change in this case was the progression from academic research to public reporting and then to real-world exploitation.
Only about a year separated research from weaponization. Open-source Agent frameworks such as ReAct, AutoGen, CrewAI, and LangGraph are no longer merely development tools. They can also serve as potential penetration-testing weapons.
Here is a minimal Python example of a ReAct Agent that illustrates the logic:
from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI
# 定义 Agent 能调用的"工具"
tools = [
Tool(name="nmap", func=lambda target: os.popen(f"nmap {target}").read(), description="网络扫描"),
Tool(name="search_cve", func=lambda cve: requests.get(f"https://cve.mitre.org/data/{cve}.json").text, description="查 CVE"),
]
# 初始化 ReAct 风格 Agent
agent = initialize_agent(tools, OpenAI(temperature=0), agent="zero-shot-react-description", verbose=True)
# 给定目标
agent.run("对 10.0.0.5 做侦察,找出可利用漏洞并生成 PoC")
This is the attacker's entry point. Once it is provided, the Agent can run the rest on its own.
Editorial Perspective
Why this matters: The public case of an Agent red team demonstrates how drastically the window for enterprise defense has narrowed. In the past, mass exploitation could lag a new vulnerability by weeks or months. Agents that run around the clock and make their own decisions could compress that window to days or even hours.
A contrarian view: This case is unlikely to cause traditional manufacturers to accelerate security spending. Large companies' procurement, compliance, and legal review cycles move far more slowly than the iteration of weaponized Agents. Attackers will outpace the organizations they target. The likely winners may not be SIEM or SOC vendors, but open-source frameworks that add sandboxing and auditing to Agents. LangGraph already includes human approval nodes, which may become a new baseline feature.
How this differs from earlier threats: Stuxnet in 2010 and WannaCry in 2017 each paired a specific tool with a specific target. This case combines a general-purpose Agent framework with arbitrary targets. Attack costs are falling structurally, while defense costs, including training, tools, and processes, continue to rise linearly. That gap may widen over the next 12 months.
What remains uncertain: The report does not identify the specific Agent framework used or confirm whether the Cummins intrusion occurred and was later remediated through responsible disclosure. Those details will require further reporting from The Verge or a technical publication from the researcher.