·13 min read·Blog·Security Operations

The Three-Hour Breach: Defending Against Autonomous AI Attack Platforms

SM
Siddhant Mishra

Threat Researcher

On November 13, the FBI issued a FLASH advisory that should give every SOC team pause: threat actors are using ARTEX, an open-source autonomous penetration testing framework, to chain full intrusion kill-chains, from initial recon to privileged access, in under three hours. Not days. Not shifts. Hours.

ARTEX isn't a theoretical risk. It has already been weaponized against South Korean financial institutions, exposing the personal data of roughly 67,000 individuals across Shinhan Bank, KB Kookmin Bank, and Hana Bank. South Korean police arrested seven suspects tied to attacks on over 90 organizations, with ARTEX reportedly used in most of them. Separately, Microsoft attributed a supply-chain attack on ConnectWise Cloud Backup, which attempted authentication against more than 2,250 downstream Microsoft 365 tenants, to Storm-0940, a China-state-aligned group operating ARTEX at scale. CrowdStrike tracked another cluster, Vapor Panda, using it against 200+ organizations across 14 countries.

This is not a niche tool anymore. Researchers have counted over 1,600 publicly exposed ARTEX consoles. The original GitHub repository, posted in July 2026 by a developer known as Autumn-27, was taken down in October. It didn't matter, forks, archives, and a commercial "ARTEX PRO" edition keep it in circulation.

What Makes ARTEX Different, From Someone Who Has Used It

I'll be direct: our team has deployed ARTEX in controlled, authorized assessments. We've studied the codebase, run it against scoped targets, and watched it operate. That firsthand experience is exactly why I'm writing this.

ARTEX is written in Go with a Next.js frontend and operates as a multi-agent framework backed by a PostgreSQL exploration graph. It doesn't ship its own model, it integrates with external LLMs (Claude, GPT, DeepSeek, Grok, and others) to orchestrate autonomous agents that handle reconnaissance, vulnerability discovery, exploitation, privilege escalation, lateral movement, and data exfiltration with minimal human input.

An operator provides a target and an objective. ARTEX decomposes it into tasks, delegates them to specialized agents, a planner, concurrent workers, a verifier, and those agents execute in loops, adapting in real time, retrying failed approaches, and switching attack paths when defenses block the first attempt. Its dual-graph architecture tracks both the exploration state (what it's tried, what it's found) and the asset graph (hosts, services, credentials, relationships). Findings feed back into the planner for the next round. The whole loop, goals decomposition, planning, parallel execution, verification, repeats autonomously until the objective is met or the budget runs out.

What struck me most running it: the adaptive retesting. When an agent's exploit attempt fails, it doesn't just retry, it re-evaluates the finding, looks for alternative paths, and pivots. This is the behavior pattern defenders need to understand, because it means blocking one technique doesn't stop the chain.

One operator can target dozens of organizations simultaneously. The critical shift is not sophistication, it is velocity and parallelism. Every technique ARTEX uses is known. Every vulnerability it exploits already has a CVE or a misconfiguration class. What changes is the compression: the gap between "exposed attack surface" and "compromised" collapses from weeks to hours.

Why Traditional Detection Falls Short

Most detection engineering assumes human-paced adversaries. We build detections around dwell time, the assumption that an attacker will linger in one phase long enough for a rule to fire, an analyst to triage, and a response to execute. ARTEX breaks that assumption.

From operating the platform, here's what I observed: a single ARTEX task can run concurrent worker agents, each executing different attack paths against the same target simultaneously. While one agent enumerates SNMP defaults, another is probing web applications, and a third is testing SMB null sessions. The planner agent reviews all results, identifies new leads, and spawns the next wave, all without a human touching the keyboard. I've watched it discover 80+ live hosts, chain misconfigurations into lateral movement paths, and begin staging findings within a single assessment window.

When an AI agent runs recon, discovers an exposed admin portal, brute-forces credentials, escalates to domain admin, and begins staging data, all within a single shift, the detection-to-response pipeline is no longer fast enough if it depends on human triage at every stage.

The FBI's advisory specifically notes that ARTEX targets the systems defenders often de-prioritize: partner portals, legacy employee applications, third-party integrations, and cloud administration interfaces. Having run it, I can confirm: the planner gravitates toward the edges of your infrastructure, the systems with the weakest authentication and the least monitoring. These are the blind spots in most telemetry architectures. You can't detect what you don't log.

How Detection Engineers Should Respond

Having operated ARTEX and studied the traces it leaves, here is what the detection engineering community needs to prioritize:

1. Telemetry first, detections second. Before writing a single rule, audit whether you have visibility into the attack surface ARTEX targets. Cloud identity logs (Azure AD sign-ins, AWS CloudTrail IAM events), API gateway logs, application-layer authentication events, and service principal activity. ARTEX's agents hit your web apps, cloud consoles, and identity providers, if those surfaces aren't instrumented, no detection rule will save you.

2. Detect velocity, not just technique. Traditional Sigma rules fire on individual events, a brute-force attempt, a suspicious process, a new service account. Against autonomous agents, the signal is in the tempo. Build correlation rules that detect compressed kill-chains: multiple ATT&CK techniques executing within abnormally short windows. If you see T1595 (Active Scanning) followed by T1190 (Exploit Public-Facing Application), T1078 (Valid Accounts), and T1098.001 (Additional Cloud Credentials) within minutes rather than days, that's your signal. From running ARTEX, I can tell you: the entire reconnaissance-to-exploitation sequence completes faster than most SOCs can triage a single P2 alert.

3. Rate-limit and throttle at the application layer. ARTEX agents generate bursts of automated requests, API calls, authentication attempts, permission enumeration. The traffic is noisy. Rate limiting on sensitive endpoints (admin portals, identity APIs, cloud management planes) is not just a performance measure; it is a detection and disruption surface. Throttle aggressively, log anomalies, and alert on sudden spikes. In our testing, rate limits were the single most effective friction point against ARTEX's agents, they force retries, slow the loop, and buy defenders time.

4. Monitor identity velocity. Watch for rapid sequences of credential validation, permission changes, new service principals, and cross-tenant authentication. The South Korean campaign and the ConnectWise attack both pivoted through identity abuse. Your UEBA baseline should flag when an identity performs more privilege-related actions in an hour than it typically does in a week. ARTEX's planner tracks credential discoveries in its exploration graph and immediately fans them out to worker agents for reuse, the time between credential discovery and lateral movement is measured in seconds.

5. Harden the edges ARTEX hunts. The FBI advisory is explicit: internet-facing applications, exposed admin interfaces, cloud administration consoles, and third-party trust relationships. These are not novel attack surfaces, but they are the ones most organizations audit last. Reduce your external footprint. Remove unused partner portals. Enforce MFA on every admin interface without exception. ARTEX's asset sync capabilities mean it can ingest subdomain, IP, and endpoint data from prior reconnaissance tools and immediately start probing, your forgotten staging environment is its first target.

6. Automate your response, not just your detection. If the adversary's attack chain is autonomous, your response chain cannot be manual. Build SOAR playbooks that trigger on correlated autonomous-attack indicators: auto-isolate hosts showing compressed kill-chain patterns, auto-revoke suspicious credential changes, auto-block IPs generating anomalous request bursts. The human reviews after containment, not before.

The Uncomfortable Truth

The 70+ open-source AI pentesting tools tracked by researchers as of early 2026 signal a permanent shift. ARTEX is the first to generate FBI advisories and international law enforcement action, but it will not be the last. The barrier to running autonomous offensive operations has collapsed, a low-skill operator with ARTEX and an LLM API key can now execute campaigns that previously required a skilled red team.

Having used these platforms firsthand, I can tell you: the detection gap isn't hypothetical. It's measurable. The time between ARTEX beginning its reconnaissance and producing actionable findings with verified exploit chains is shorter than the mean time to triage at most SOCs I've audited.

For detection engineers and threat hunters, the mandate is clear: we must engineer for speed, not just coverage. Our detections need to fire faster. Our telemetry needs to cover the surfaces that autonomous tools target first. And our response playbooks need to execute at machine speed, because the adversary already does.

The three-hour breach window is not a warning about the future. It is a description of November 2026.

Appendix: Detection Rules for Autonomous AI Attack Patterns

Below are five detection rules engineered from real ARTEX behavioral patterns observed during authorized assessments. These target the telemetry signatures that autonomous platforms generate, not individual CVEs, but the operational tempo and chaining behavior that distinguish AI-driven intrusions from human adversaries.


Detection 1: Compressed Kill-Chain, Recon to Exploitation in Rapid Succession

Logic: Alert when a single source IP triggers scanning, authentication, and exploitation indicators within a 15-minute window. ARTEX's planner-worker loop produces this pattern consistently, recon findings feed directly into exploitation attempts without the pause a human operator would take.

title: Compressed Kill-Chain - Autonomous Agent Recon-to-Exploit Velocity
id: 7a3f1e02-d4c8-4b9a-af12-9e3c5d7b8a01
status: experimental
description: >
  Detects a single source IP performing port scanning, authentication attempts,
  and web exploitation within a compressed window, consistent with autonomous
  AI pentesting frameworks like ARTEX operating in planner-worker loops.
references:
  - https://www.ic3.gov/CSA/2026/261113.pdf
  - https://attack.mitre.org/techniques/T1595/
  - https://attack.mitre.org/techniques/T1190/
logsource:
  category: network_connection
  product: firewall
detection:
  scan_phase:
    action: 'allowed'
    dst_port|count|gte: 50
    timeframe|lte: 300
  auth_phase:
    dst_port:
      - 443
      - 8443
      - 8080
    http_method: 'POST'
    url|contains:
      - '/login'
      - '/auth'
      - '/api/token'
      - '/oauth'
    count|gte: 10
    timeframe|lte: 300
  exploit_phase:
    http_method: 'POST'
    url|contains:
      - '/admin'
      - '/api/'
      - '/graphql'
      - '/execute'
    response_code:
      - 200
      - 201
      - 500
  filter_scanners:
    src_ip|cidr:
      - '10.0.0.0/8'  # Adjust for your authorized scanner ranges
  condition: (scan_phase and auth_phase and exploit_phase) and not filter_scanners
  timeframe: 15m
  group-by: src_ip
level: high
tags:
  - attack.reconnaissance
  - attack.t1595
  - attack.initial_access
  - attack.t1190
  - attack.t1078
  - cve.autonomous_ai
falsepositives:
  - Authorized penetration testing tools
  - Vulnerability scanners with authentication testing enabled

Detection 2: Burst Authentication Spray Across Multiple Services

Logic: ARTEX's concurrent worker agents fan out credential discoveries immediately. When the planner finds valid credentials for one service, it spawns workers to test those same credentials across every reachable authentication endpoint in parallel. This produces a distinctive burst pattern: the same source attempts authentication against many distinct services within seconds.

title: Burst Authentication Spray - Multi-Service Credential Reuse
id: 7a3f1e02-d4c8-4b9a-af12-9e3c5d7b8a02
status: experimental
description: >
  Detects a single source attempting authentication against multiple distinct
  services or endpoints in a short burst, consistent with autonomous agent
  credential fan-out after initial credential discovery.
references:
  - https://www.ic3.gov/CSA/2026/261113.pdf
  - https://attack.mitre.org/techniques/T1078/
logsource:
  category: webserver
  product: any
detection:
  selection:
    cs_method: 'POST'
    cs_uri_stem|contains:
      - '/login'
      - '/auth'
      - '/signin'
      - '/api/authenticate'
      - '/oauth/token'
      - '/saml/SSO'
      - '/adfs/ls'
  condition: selection | count(cs_uri_stem) by src_ip > 5
  timeframe: 2m
level: high
tags:
  - attack.credential_access
  - attack.t1078
  - attack.t1110.003
  - cve.autonomous_ai
falsepositives:
  - SSO health checks hitting multiple service providers
  - Load balancer probes with authentication endpoints

Detection 3: Rapid Cloud Permission Enumeration

Logic: After gaining initial cloud access, ARTEX agents systematically enumerate IAM roles, policies, and cross-account trust relationships. The ConnectWise campaign demonstrated this, the agents queried permission boundaries to find escalation paths to downstream tenants. This detection targets the enumeration velocity.

title: Rapid Cloud IAM Enumeration - Autonomous Agent Privilege Discovery
id: 7a3f1e02-d4c8-4b9a-af12-9e3c5d7b8a03
status: experimental
description: >
  Detects rapid enumeration of IAM roles, policies, and trust relationships
  from a single identity, consistent with autonomous AI agents performing
  privilege discovery after initial cloud access.
references:
  - https://www.ic3.gov/CSA/2026/261113.pdf
  - https://attack.mitre.org/techniques/T1087.004/
  - https://attack.mitre.org/techniques/T1580/
logsource:
  product: aws
  service: cloudtrail
detection:
  selection_enum:
    eventName:
      - 'ListRoles'
      - 'ListPolicies'
      - 'GetPolicy'
      - 'GetPolicyVersion'
      - 'ListAttachedRolePolicies'
      - 'ListAttachedUserPolicies'
      - 'GetAccountAuthorizationDetails'
      - 'ListAccountAliases'
      - 'GetCallerIdentity'
      - 'ListUsers'
      - 'ListGroupsForUser'
      - 'SimulatePrincipalPolicy'
  condition: selection_enum | count(eventName) by userIdentity.arn > 8
  timeframe: 5m
level: high
tags:
  - attack.discovery
  - attack.t1087.004
  - attack.t1580
  - cve.autonomous_ai
falsepositives:
  - Cloud security posture management (CSPM) tools
  - Terraform/CloudFormation plan operations
  - IAM audit scripts run by cloud administrators

Detection 4: Automated Pivot, Service Discovery Followed by Lateral Tool Execution

Logic: ARTEX doesn't just find services, its exploration graph feeds discoveries directly into the next worker round. When it discovers an internal service (SMB, WinRM, SSH, RDP), the planner immediately dispatches workers to attempt access with any credentials already in its graph. This detection correlates internal service discovery with subsequent lateral movement tool execution on the same host.

title: Automated Pivot - Discovery-to-Lateral-Movement Chaining
id: 7a3f1e02-d4c8-4b9a-af12-9e3c5d7b8a04
status: experimental
description: >
  Detects a host performing internal service enumeration (port scans on
  lateral movement ports) followed by remote execution tool activity within
  a compressed window, consistent with autonomous agent pivot behavior.
logsource:
  product: windows
  service: sysmon
detection:
  discovery:
    EventID: 3
    Initiated: 'true'
    DestinationPort:
      - 445
      - 5985
      - 5986
      - 22
      - 3389
    DestinationIp|cidr:
      - '10.0.0.0/8'
      - '172.16.0.0/12'
      - '192.168.0.0/16'
  lateral_exec:
    EventID: 1
    Image|endswith:
      - '\\PsExec.exe'
      - '\\wmic.exe'
      - '\\winrs.exe'
      - '\\ssh.exe'
      - '\\mstsc.exe'
      - '\\net.exe'
      - '\\smbclient.exe'
    CommandLine|contains:
      - '\\\\' # UNC path indicating remote target
      - '-r:'
      - '/node:'
  condition: discovery | count(DestinationIp) by SourceIp > 10 and lateral_exec
  timeframe: 10m
  group-by: Computer
level: critical
tags:
  - attack.lateral_movement
  - attack.t1021.002
  - attack.t1021.006
  - attack.discovery
  - attack.t1046
  - cve.autonomous_ai
falsepositives:
  - IT administration tools performing bulk remote management
  - Network monitoring solutions

Detection 5: Anomalous API Request Burst with User-Agent Rotation

Logic: ARTEX agents making HTTP requests through its send_request tool generate high-volume API traffic. Sophisticated operators configure user-agent rotation, but the request cadence, dozens of requests per second to the same application with varying user-agents, is itself the signal. This detection looks for the combination of high request rate and user-agent diversity from a single source, which is a hallmark of automated tooling regardless of the specific framework.

title: Anomalous API Burst with User-Agent Diversity - Automated Tooling Indicator
id: 7a3f1e02-d4c8-4b9a-af12-9e3c5d7b8a05
status: experimental
description: >
  Detects a single source IP generating a high volume of requests with
  multiple distinct user-agent strings within a short window, indicating
  automated tooling with agent rotation, a pattern observed in autonomous
  AI attack frameworks.
references:
  - https://www.ic3.gov/CSA/2026/261113.pdf
logsource:
  category: webserver
  product: any
detection:
  high_volume:
    src_ip|count|gte: 100
    timeframe|lte: 60
  ua_diversity:
    cs_user_agent|count|gte: 5
    timeframe|lte: 60
  condition: high_volume and ua_diversity
  timeframe: 1m
  group-by: src_ip
level: medium
tags:
  - attack.reconnaissance
  - attack.t1595.002
  - cve.autonomous_ai
falsepositives:
  - API load testing tools
  - Content delivery networks aggregating multiple clients behind a single IP
  - Corporate proxies with diverse client populations

These detections are released as-is for the community. Tune thresholds to your environment's baseline. The timeframes and counts above reflect patterns observed in controlled assessments, production environments with higher baseline traffic may require adjustment.


Siddhant Mishra leads threat research, hunting, and detection engineering at Bloo. The views expressed are his own.


Sources:

We use cookies to provide essential site functionality and, with your consent, to analyze site usage and enhance your experience. View our Privacy Policy