TL;DR
- What happened: Suspected Chinese state-aligned operators deployed autonomous AI agents using the open-source Cairn framework to conduct a multi-stage intrusion campaign that discovered and exploited a zero-day vulnerability in MONAI Label.
- Who is affected: Organisations running exposed instances of MONAI Label (an open-source medical imaging AI framework), along with enterprise networks hosting open-source AI tooling, exposed Redis instances, and unauthenticated internal microservices.
- Impact: The AI agents systematically mapped application APIs, identified a path traversal flaw, achieved arbitrary file write, and executed a Python reverse shell with full root privileges within 11 minutes of discovery.
- What to do now: Audit and patch MONAI Label installations immediately; implement strict path canonicalisation on file upload parameters; restrict egress traffic from application runtime pods; enforce mutual TLS (mTLS) and authentication on internal vector databases and caching layers.
In September 2026, threat actors deployed autonomous ai agents to identify and exploit an undisclosed zero-day path traversal vulnerability in MONAI Label, an open-source medical imaging application. The attack campaign targeted university networks in East Asia outside Mainland China over a 48-hour window beginning 8 September 2026. The deployment marks a significant transition in cyber security threat modeling: agentic software frameworks moving from controlled research environments into active, unassisted operational exploitation against production targets.
The campaign was uncovered when the Amazon Threat Intelligence Team identified a server hosting a publicly accessible instance of Cairn on 10 September 2026. Analysis of the instance provided visibility into the operational logic, decision loops, and command history executed by the agents. As reported by The Register and detailed by Amazon Chief Information Security Officer CJ Moses, the agents operated without human intervention for extended periods, systematically testing fallback attack vectors across multiple targets before discovering the zero-day flaw.
The incident highlights the operational viability of autonomous agent frameworks in offensive cyber operations. Rather than relying on static scripts or pre-compiled exploit chains, these agents evaluate response signatures, adapt after failed execution attempts, scrape targeted intelligence from public sources, and weaponise newly discovered logic flaws at machine speed. Understanding the mechanics of this intrusion is essential for platform engineers, infrastructure architects, and security operations center (SOC) teams defending high-value systems, where distinguishing between operational outages and active attacks requires rapid triage procedures.
Autonomous AI Exploitation Moves from Lab to Field
For several years, defensive security research evaluated autonomous agent capabilities within controlled benchmarks and capture-the-flag competitions. The September 2026 campaign represents a definitive shift from theoretical proof-of-concept models to live, state-aligned offensive operations. Over a 48-hour window starting 8 September 2026, autonomous agents conducted continuous reconnaissance, exploitation, and post-exploitation actions against academic infrastructure in East Asia.
The core engine behind this operation was Cairn, an open-source AI agent framework originally designed for automated penetration testing and red teaming. Built to interface with large language models (LLMs) and local decision engines, Cairn equips an agent with tools to parse command outputs, map attack surfaces, manage local memory states, and construct dynamic execution trees. When provided with target parameters, the framework iterates through attack vectors, evaluating HTTP response codes, system error messages, and process outputs to select its next command.
Framework Dual-Use Dynamics
The Cairn framework demonstrates the narrow boundary between automated defensive auditing tools and offensive software weapons. While designed for legitimate penetration testing, its agentic architecture enables threat actors to scale high-velocity vulnerability research across distributed external subnets without ongoing operator overhead, similar to broader industry challenges with AI security integration models.
Amazon Threat Intelligence gained direct visibility into the campaign on 10 September 2026 after discovering an exposed server hosting an active Cairn deployment. The instance contained complete operational logs, active agent memory states, and prompt histories. According to Amazon CISO CJ Moses, the operational evidence confirms that the agents managed complex multi-stage attack chains for nearly a full day without human oversight, adapting their tactics dynamically when initial vector paths failed.
This development fundamentally alters the temporal dynamics of vulnerability exploitation. Traditional threat actor workflows require human operators to manually reverse-engineer patches, write fuzzers, analyze application routines, and formulate working exploit payloads. By delegating endpoint analysis and payload generation to the Cairn framework, threat groups collapse the window between target exposure and host compromise into minutes.
Anatomy of the 48-Hour Agentic Intrusion Campaign
The campaign proceeded through a series of structured operational phases over 48 hours. Analysis of the exposed Cairn instance revealed operational artifacts that provide insight into the campaign’s origin and structure. Prompts submitted to the agent framework were written in Simplified Chinese, and script execution timestamps were set to China Standard Time (CST). These indicators point to suspected Chinese threat actors managing the underlying infrastructure.
The operational cadence demonstrated a clear division of labor between human handlers and autonomous software. While the agents executed high-volume scanning, payload creation, and error analysis, human operators intervened only to provide structural routing or elevated pivot capabilities when network boundaries prevented further movement.
Human-Agent Collaboration Model
Autonomous agents handle the technical friction of target mapping, protocol fuzzing, and initial zero-day weaponisation. Human operators re-enter the loop primarily to provision infrastructure, bypass network perimeters, and establish persistent proxies between compromised subnets.
The following operational flow illustrates the interaction between the Cairn autonomous agents, target environments, and the human controller throughout the 48-hour intrusion window:
+-----------------------------------------------------------------------------------+
| HUMAN OPERATOR (CST Timezone) |
| - Submits seed prompts in Simplified Chinese |
| - Provisions proxy tunnels for inter-network pivoting |
+-----------------------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------------------+
| CAIRN AUTONOMOUS AGENT ENGINE |
| - Maintains local execution state and contextual memory |
| - Interprets HTTP / service responses and selects next step |
+-----------------------------------------------------------------------------------+
| | |
| Phase 1: 16-Hour Session | Phase 2: 6-Hour Session | Phase 3: 11-Min Pivot
v v v
+-----------------------------+ +-----------------------------+ +-----------------------------+
| TARGET 1: REDIS & DB | | TARGET 2: GPU SERVER | | TARGET 3: MONAI LABEL APP |
| - 148 sequential actions | | - Scrapes papers/websites | | - Endpoint API mapping |
| - Sandbox escape attempts | | - Curates 80 real usernames | | - Path traversal discovery |
| - Replication abuse & SSRF | | - Targeted spray against | | - Arbitrary Python write |
| - Log4Shell & SSH/PG spray | | SSH and GPU services | | - Root reverse shell executed|
| [RESULT: ALL FAILED] | | [RESULT: FAILED] | | [RESULT: COMPROMISED] |
+-----------------------------+ +-----------------------------+ +-----------------------------+
|
v
+-----------------------------+
| SECONDARY NETWORK PIVOT |
| Human provisions proxy; |
| agent re-exploits secondary |
| MONAI Label target. |
+-----------------------------+
When the agents successfully executed the initial MONAI Label exploit, a human operator supplied a proxy connection. This tunnel allowed the agent to pivot from the initial access vector into a secondary university network running an identical vulnerable software stack, replicating the zero-day compromise automatically.
Reconnaissance, Adaptability, and Iterative Failure Handling
The defining capability of the Cairn framework during this campaign was its ability to manage prolonged execution sequences without halting on intermediate errors. Prior to locating the target application, the agents engaged in aggressive, multi-vector testing across internal and perimeter services.
The 16-Hour Redis Exploitation Sequence
In one primary phase, the agents targeted a university Redis server across a 16-hour session, executing 148 sequential actions. Rather than executing a simple, static spray, the agent evaluated the target’s configuration after each response, cycling through distinct exploitation techniques:
- Replication Abuse: The agent attempted to configure the target Redis instance as a replica of an external rogue Redis server using
SLAVEOF/REPLICAOFcommands, attempting to force the target to download and load a malicious shared object (.so) file into memory. - Configuration Rewriting: Attempts were made to use
CONFIG SET dirandCONFIG SET dbfilenameto overwrite local system files, targeting path destinations such as/var/spool/cron/crontabs/and~/.ssh/authorized_keys. - Sandbox Escapes: The agent attempted to break out of the embedded Lua execution environment using known memory-corruption constructs and unpatched engine quirks to achieve host command execution.
- Memory Corruption: High-frequency malformed command strings were submitted to trigger buffer overflows within custom module implementations.
Despite 148 consecutive iterations failing due to host hardening and network access rules, the agent did not crash or abort the campaign. Instead, it systematically marked the target host as non-viable via those mechanisms and pivoted to secondary attack vectors.
Fallback Operations and Target Harvesting
When the Redis vectors failed, the agent executed a series of automated fallback tactics targeting adjacent services, as detailed in reporting by The Register:
| Target Service | Attack Mechanism Attempted | Agent Behaviour and Logic |
|---|---|---|
| Java Web Applications | Log4Shell Injection | Injected JNDI lookup strings into HTTP headers (User-Agent, X-Forwarded-For) and query parameters. |
| Qdrant Vector Database | Server-Side Request Forgery (SSRF) | Probed co-located API endpoints to force outbound HTTP requests back into internal vector store endpoints. |
| PostgreSQL & SSH | Credential Spraying | Iterated through standard systemic account lists using common default password lists. |
Concurrently, in a separate 6-hour targeted operation, the agents focused on a university GPU compute server. Recognising that simple dictionary attacks against SSH were failing, the agents navigated to the university’s public websites, faculty directories, and online academic publications. The agents parsed these unstructured documents to compile a list of 80 real usernames affiliated with the target institution, subsequently running a targeted credential spray against the GPU cluster access points.
The 11-Minute Zero-Day Discovery in MONAI Label
The trajectory of the campaign changed when the autonomous agents encountered an exposed instance of MONAI Label. MONAI Label is an open-source medical imaging AI framework designed to assist researchers and clinicians in annotating 3D medical images using intelligent segmentation algorithms. Because MONAI Label is designed for high-performance AI research, deployments are frequently integrated directly with accelerated GPU hardware and elevated execution contexts.
Upon locating the web endpoint, the Cairn agent initiated an automated surface discovery routine. The process from initial endpoint discovery to root system compromise took exactly 11 minutes:
- Framework & API Identification (Minutes 0–3): The agent submitted structure probes to identify framework signatures, identifying MONAI Label’s underlying REST API structure, OpenAPI documentation endpoints, and active routing tables.
- Parameter Isolation (Minutes 3–6): The agent catalogued file management and annotation upload endpoints, isolating a web upload endpoint that accepted a user-controlled
filenameparameter. - Path Traversal Testing (Minutes 6–8): The agent generated targeted directory traversal sequences (e.g., sequence patterns containing
../variants, null-byte injections, and URL-encoded structures) within thefilenameparameter to determine whether user input escaped the intended upload root directory. - Arbitrary File Write (Minutes 8–9): Upon confirming that path traversal sequences passed un-sanitised to the underlying filesystem write operations, the agent constructed a multi-line payload containing executable Python code and wrote it into an active system path.
- Reverse Shell Execution (Minutes 9–11): The agent triggered the execution of the newly created Python script, establishing an outbound reverse TCP shell callback to the attacker-controlled infrastructure.
# Diagnostic simulation of a path traversal parameter check against an un-sanitised file endpoint
# Test in non-production environments only
curl -i -X POST "http://<target_host>:8000/api/v1/upload" \
-H "Content-Type: multipart/form-data" \
-F "[email protected]" \
-F "filename=../../../../../../tmp/system_update.py"
Because the container or application host process was running under elevated administrative rights, the resulting Python shell granted the agent complete root access to the target host. From this position, the agent could access mounted storage arrays, inspect local GPU pipelines, or harvest cached API keys.
Undisclosed Vulnerability Technical Metrics
The official source disclosures do not publish a designated CVE identifier, CVSS severity score, specific software version numbers, or exact source code function lines for this MONAI Label vulnerability. Systems administrators must verify patch state by referencing the official vendor security advisories released following Amazon’s notification to the MONAI Label maintainers.
Commercial Data Theft and State Espionage via Agentic Frameworks
The deployment of Cairn against East Asian academic networks is not an isolated incident. Threat intelligence research published by Gambit Security indicates that Chinese threat actors have operationalised the Cairn framework across extensive commercial cyber operations.
According to Gambit Security, the same core agent framework was deployed across at least 105 distinct attack campaigns, compromising at least 27 target organisations to varying degrees. These operations spanned multiple key economic sectors, demonstrating that autonomous exploitation frameworks are actively deployed for both strategic state intelligence gathering and commercial data exfiltration, mirroring risks seen in major corporate breaches such as the Chainalysis credential exposure:
- Hospitality: A Fortune 500 hospitality enterprise suffered network intrusion, leading to database access.
- Aviation: A major US commercial airline experienced endpoint probing and infrastructure access.
- Industrial Distribution: A major US distributor of industrial supplies was compromised, exposing internal supply-chain systems.
- Retail: An online fashion retailer suffered initial access exploitation targeting customer and transaction data.
In several of these commercial incidents, threat actors deployed Cairn alongside two additional open-source AI harness frameworks. These tools automated the exfiltration of credit card repositories, user credential stores, and proprietary corporate databases. The speed and scale of these dual-use deployments demonstrate how quickly advanced penetration testing automation can be reconfigured for persistent cyber espionage and financial crime.
Defensive Architecture for Agent-Driven Reconnaissance and Exploitation
Defending against high-velocity, autonomous agents requires structural changes to perimeter monitoring, API design, and network isolation. Traditional SOC detection models depend on human dwell-time metrics, alerting when anomalous actions occur over hours or days. When an autonomous agent transitions from initial API scanning to arbitrary root command execution in 11 minutes, manual triage models fail.
Detecting High-Velocity Endpoint Traversal
Autonomous agents generate distinct network traffic profiles during their API mapping and parameter-fuzzing phases. While human operators manually evaluate HTTP responses, agents issue continuous, tightly spaced HTTP requests designed to probe boundary limits. Security teams must configure Web Application Firewalls (WAF) and ingress proxies to detect high-frequency parameter mutations and systematic path traversal testing.
# Example HAProxy configuration to rate-limit high-velocity upload endpoint traversal attempts
frontend http_in
bind *:8080
mode http
# Track requests by client IP over a 10-second window
stick-table type ip size 100k expire 10s store http_req_rate(10s)
http-request track-sc0 src
# Define path match for application upload endpoints
acl is_upload_endpoint path_beg /api/v1/upload
# Flag IP addresses exceeding 15 request attempts per 10 seconds on upload paths
acl high_upload_rate src_http_req_rate(10s) gt 15
# Deny traffic violating the velocity baseline
http-request deny deny_status 429 if is_upload_endpoint high_upload_rate
Hardening File Upload Endpoints against Path Traversal
To eliminate path traversal vulnerabilities (such as the zero-day discovered in MONAI Label), application code must strictly sanitise and canonicalise all incoming file paths. User-controlled filenames must never be passed directly to underlying filesystem operations or shell execution paths.
# Diagnostic script to inspect running Python application processes for insecure elevated execution
# Run as root or administrator on host system
ps aux | grep -E "python|monai" | grep -v grep
File handling logic should enforce three core defensive layers:
- Filename Striping and UUID Re-mapping: Discard user-supplied filenames entirely for storage operations. Assign a cryptographically secure, server-generated UUID to the saved file on disk.
- Path Canonicalisation Checks: If user-supplied relative paths are required, verify that the absolute, resolved path resides within the designated storage directory before executing write operations.
- Mount Point Execution Isolation: Mount temporary and permanent upload directories with the
noexec,nosuid, andnodevflags to prevent executed web shells from invoking secondary commands. Platform engineers managing Kubernetes cluster workloads can further enforce isolation using AWS Nitro microVM pod sandboxing to contain runtime breakouts.
Securing Vector Databases and Caching Layers
The campaign demonstrated that autonomous agents aggressively target underlying infrastructure components like Qdrant and Redis when primary web vectors fail. Internal services must be hardened assuming that external perimeter controls may be bypassed:
- Redis Security Baseline: Bind Redis services exclusively to loopback or private internal interfaces (
bind 127.0.0.1). Enable mandatory command-renaming or disabling for destructive administrative options (e.g.,rename-command CONFIG ""andrename-command MODULE ""inredis.conf). Enforce strong authentication usingrequirepass. - Qdrant Vector DB Hardening: Never expose vector store REST or gRPC ports (
6333,6334) directly to untrusted networks. Require mutual TLS (mTLS) and mandate explicit API token authorization for all read and write queries. - SSRF Mitigation: Deploy strict egress filtering rules using network policies to block web application runtimes from initiating direct, unauthenticated connections to internal microservice management ports.
Tactical Mitigation Checklist for Infrastructure Defenders
Platform and security engineering teams should review the following prioritised action checklist to assess exposure to agentic exploitation frameworks and secure exposed software assets:
| Domain | Tactical Action Item | Target Outcome / Verification |
|---|---|---|
| Application Security | Audit and update all MONAI Label instances to the latest vendor-patched release. | Eliminates the zero-day path traversal vector identified in the September 2026 campaign. |
| Input Validation | Enforce path canonicalisation and filename re-mapping on all file upload REST API endpoints. | Prevents directory traversal payloads (../) from escaping intended root storage boundaries. |
| Egress Security | Implement strict egress network filtering on application worker nodes and container pods. | Blocks outbound TCP reverse shell callbacks from establishing connection to rogue C2 infrastructure. |
| Identity & Access | Enforce non-root execution contexts across all application containers and AI framework services. | Prevents arbitrary file write vulnerabilities from immediately escalating to host-level root compromise. |
| Database Hardening | Disable Redis CONFIG and MODULE commands; enforce mTLS across Qdrant instances. |
Neutralises automated fallback exploit paths targeting internal state stores and vector engines. |
| WAF / Rate Limiting | Configure rate-limiting policies for high-frequency API parameter fuzzing and sequential probing. | Throttles automated agent reconnaissance, increasing the likelihood of early anomaly alert triggering. |
# Diagnostic check: Verify egress network filtering rules on Linux runtime hosts
# Test in staging environments
iptables -L OUTPUT -v -n
Key Takeaways for Technical Leadership
The operational deployment of the Cairn framework against medical imaging software and enterprise subnets marks a permanent change in offensive tradecraft. Technical leaders and architects must incorporate three reality shifts into their long-term threat models:
- Time Compression: Autonomous AI agents collapse the window between target selection, endpoint discovery, zero-day identification, and host compromise down to minutes. Defender SLA metrics that rely on multi-hour human triage windows are no longer effective against agentic attacks.
- Resilience through Iteration: Unlike static exploits or traditional automated scanning scripts, agentic frameworks evaluate failure states, adapt their techniques, scrape context from public targets, and shift dynamically to adjacent internal attack surfaces without human intervention.
- Zero-Trust Internal Boundaries: As agent-driven zero-days allow rapid initial perimeter access, internal microservices—including vector stores like Qdrant and caching engines like Redis—must enforce explicit authentication, strict network isolation, and non-root execution boundaries.
Frequently asked questions
What is the Cairn framework, and how is it used in attacks?
Cairn is an open-source AI agent framework originally developed for automated penetration testing. Threat actors use Cairn to automate multi-stage attack workflows. The framework connects LLMs to system execution interfaces, allowing autonomous agents to interpret tool outputs, modify attack strategies, fuzz endpoints, and execute exploit commands without ongoing human direction.
How did the AI agents discover the zero-day in MONAI Label so quickly?
The agents used structured API mapping routines to analyse MONAI Label endpoints. Upon isolating an upload endpoint accepting a user-controlled filename parameter, the agent generated sequential path traversal strings to test file write limits. Within 11 minutes of initial endpoint discovery, the agent confirmed the flaw, achieved arbitrary file write, and executed a Python reverse shell.
Did the autonomous agents operate completely without human supervision?
The agents executed autonomous, multi-hour operations involving complex failure analysis, tool selection, and exploit generation without real-time human intervention. However, the operational model remains hybrid: human operators provided seed prompts in Simplified Chinese and intervened at critical junctures, such as provisioning proxy tunnels to allow agents to pivot into secondary networks.
What other systems were targeted before the MONAI Label flaw was identified?
Prior to exploiting MONAI Label, the agents conducted a 16-hour campaign against a Redis instance, executing 148 sequential actions targeting sandbox escapes, memory corruption, and replication features. They also attempted Log4Shell payload injections, SSRF attacks against a co-located Qdrant vector database, credential spraying against SSH and PostgreSQL, and scraped academic papers to target a GPU server.
How can security teams detect AI-driven automated penetration tools?
Security teams can identify agentic activity by monitoring for high-velocity API parameter testing, rapid sequential endpoint traversal, and rapid cycles of varying exploit attempts originating from single sources. Implementing rate limiting on sensitive upload endpoints, enforcing non-root container constraints, restricting egress shell callbacks, and requiring strict authentication on internal datastores significantly reduce agent success rates.
Sources and further reading
- China attackers deployed AI agents that autonomously found and exploited a 0-day to take over a university server (The Register · Security)
This article was drafted with AI assistance from the publicly cited sources and passed automated checks for structure and sourcing. Verify critical details against the vendor advisories linked above before acting.