3 hrs

fastest intrusions, targeting to privileged access, per the FBI

2,250+

downstream tenants reached through one supply chain compromise

1,600+

ARTEX consoles exposed on the internet in early November

67,000

people whose data left South Korean financial institutions

ARTEX did not invent an attack, it removed the wait

The FBI's warning about ARTEX is a story about time. Every entry point the FBI lists for this AI framework is a finding that has sat in penetration test reports for a decade, and what ARTEX changed is how long an attacker needs to chain them: in the fastest cases, under three hours from first targeting to privileged access.

Most security programs quietly run on a time budget. A medium finding on a partner portal goes into the backlog with a 90 day fix window. A hardcoded credential in a JavaScript bundle gets a ticket and a sprint. A legacy API with no authentication gets an exception because the business unit that built it is still deciding whether it is needed. Each decision assumes an attacker still has to do the slow work of understanding the weakness and connecting it to something else. That slow work was the control, even though nobody wrote it down as one.

ARTEX does the slow work. Its agents take a goal written in plain language, break it into tasks, run the scans, read the results, and try the next step, with minimal human input once the objective is set. They are not smarter than a good human operator. They are tireless, parallel and cheap, and they do not lose interest in the employee expense app that nobody on the security team has looked at since it launched.

So the question this alert puts to a security leader is not "are we exposed to ARTEX?" ARTEX is a delivery mechanism. The question is: which of the findings we already know about would we still be comfortable leaving open if the attacker needed three hours instead of three weeks? For most organizations we test, the honest answer is fewer than the backlog suggests.

What the FBI FLASH on ARTEX says

On 13 Nov 2026 the FBI published FLASH-20261113-001, marked TLP:CLEAR, titled as a threat overview of the ARTEX autonomous penetration testing framework. It runs to 13 pages and draws on work from Microsoft, Google, Mandiant, CrowdStrike, Zscaler, Censys, Akamai, Check Point and CERT-EU.

The core facts, in the FBI's terms:

  • ARTEX is an open source, LLM driven, multi agent penetration testing platform written in Go. It does not ship its own model. It plugs into external providers, and the FBI names Anthropic Claude, OpenAI GPT, DeepSeek, GLM, Grok and Kimi.
  • In attacker controlled instances the FBI says Chinese models are most prevalent, with DeepSeek Flash family models dominating because of cost and what the FBI calls a lack of observable guardrails when the request is framed as penetration testing.
  • It was released on GitHub in July 2026 as a tool for authorized testing. The developer made the repository unavailable on 8 Oct 2026 after reports of abuse. It lives on through community forks, localized variants, archived copies and a commercial version, ARTEX PRO.
  • A variety of malicious actors have used it since at least August 2026 against financial services, government, technology, defense, semiconductor, energy, healthcare, manufacturing, telecommunications and legal organizations.
  • Some intrusions went from initial targeting to privileged access in under three hours.
  • As of early November 2026, researchers identified over 1,600 publicly exposed ARTEX consoles. The FBI expects the real number of deployments to be significantly higher.

Two campaigns anchor the document. The first is a financially motivated operation against South Korean financial institutions that, per the FBI, ended with personal information on approximately 67,000 individuals exfiltrated. The second is a supply chain compromise of ConnectWise Cloud Backup customers that the FBI says enabled access to more than 2,250 downstream tenants. The Record reports that Microsoft tied that attack to Chinese state backed actors using ARTEX, and BleepingComputer reports that it compromised application identities used by the backup service rather than user passwords.

FBI FLASH-20261113-001 Critical
  • Subject //

    ARTEX autonomous penetration testing framework
  • Published //

    13 Nov 2026, TLP:CLEAR
  • Built in //

    Go, with external LLMs as the engine
  • Abused since //

    at least August 2026
  • Fastest intrusions //

    under three hours to privileged access
  • Exposed consoles //

    over 1,600 in early November
  • Patch //

    none to apply; the entry points are configuration, credentials and app flaws

The line in that panel that should reset priorities is the last one. There is no ARTEX patch, because there is no ARTEX vulnerability. The FBI's table of initial access activity reads like a findings index: unsigned SAML assertions, XXE, anonymous file upload, abused cross account cloud trust from a partner tenant, compromised vendor credentials used through B2B federation, SSRF, hardcoded administrator passwords in single page application JavaScript bundles, missing authentication on web APIs, command injection, IDOR, weak administrative credentials, template injection, SQL injection, authentication bypass, and stolen VPN configurations with leaked credentials. SecureWorld put the point plainly: none of the headline entry points is an unpatched CVE.

How an ARTEX intrusion reaches privileged access

The FBI maps observed ARTEX activity across the full ATT&CK lifecycle. The shape is familiar to anyone who has run an external test that turned into an internal one. The difference is that no phase waits for a person.

Figure 01

From a forgotten portal to the domain

  1. 01

    Map //

    Agents scan, fuzz and test every credential they find in parallel.

  2. 02

    Enter //

    One ordinary flaw on a peripheral app gives a foothold.

  3. 03

    Hold //

    Web shells, new OAuth app secrets, new cloud keys.

  4. 04

    Climb //

    Cloud roles, Kerberoasting, DCSync, forged tokens.

  5. 05

    Take //

    Databases, blobs and mailboxes staged for exfiltration.

Result //

A backlog of medium findings became privileged access in an afternoon.

Every stage is a known technique. The agents remove the human pause between them.

Reconnaissance in the cloud is fast and quiet in a specific way. The FBI describes agents mapping the effective permissions of Azure credentials, including SAS tokens, service principals, Kudu credentials and storage account keys, using sub second capability checks, test blob writes and deletes, and ARM deployment validation dry runs. On AWS, it describes agents testing compromised IAM user permissions with DryRun flags. A careful human tester does the same with one key over half an hour. The agents do it for every key they find, at once.

Persistence is layered, and much of it lives in identity rather than on disk. Alongside JSP and PHP web shells and open source remote access tools named in the FLASH (WISP, vshell, AdaptixC2), the FBI lists account takeover through password resets, credentials added to existing OAuth applications, new SSH key pairs and newly allocated Elastic IPs. An application secret quietly added to a trusted app survives a password reset, a reimaged laptop and a removed web shell. That is the persistence we see defenders miss most often, and we wrote about the identity side of it in our post on Microsoft 365 token replay after a password reset.

The climb uses the whole playbook. Compute launched with high value IAM roles, Kerberoasting, SQL injection to dump database credentials, DCSync to take the krbtgt key, resource based constrained delegation, cloud metadata queried through XXE, and an administrator token forged with unrotated authentication keys. Internally, agents enumerated over 110,000 Active Directory objects, read LAPS passwords, and checked which Windows machines lacked an EDR sensor.

One detail is good news. The FBI records that attempted lateral movement to domain controllers through pass the ticket, WinRM, Kerberos relay and pass the hash was blocked by endpoint protection. Controls that already work still work against an agent. The agent does not get better at evading a well tuned EDR because it is fast. It gets better at finding the machine the EDR is not on, which is why sensor coverage inventory appears in the FLASH as an attacker activity.

Why the peripheral apps are the target

The FBI devotes a bullet to what it calls exploitation of overlooked attack surfaces: partner and supplier portals, mobile backends, employee applications, sales support systems, legacy services, third party integrations, and applications created across different business units. It returns to the same list in its first recommendation. That repetition is the most useful sentence in the document for a buyer of security testing.

Here is why those systems lose. A flagship application gets a threat model, a security review before launch, a penetration test every year and a team that answers the pager. The expense tool a business unit commissioned in 2021 gets none of that. It authenticates against the same identity provider, it often holds an API key with more scope than it needs, and it frequently has the hardcoded administrator password in its front end bundle that the FBI lists by name. The limit used to be attention: a person working a target picks the obvious door. An agent swarm tries every door.

That changes how severity should be read. A typical report rates a missing authentication check on a low traffic internal API as medium, because exploitation needs knowledge of the endpoint and the data behind it looks modest. Both assumptions weaken here. The agent enumerates the endpoint as a matter of course, and the data behind it matters less than what it chains to: a token, a connection string, a service principal secret, a path into a cloud account. Severity was always meant to include exploitability and blast radius. ARTEX moves both inputs at once, so the same finding deserves a higher number this quarter than it got last year, with no change to the code.

The supply chain angle follows the same logic one level up. The FBI says agents can systematically map trust relationships between organizations and pivot from a weaker supplier into a larger customer, and it cites agents modifying iOS application distribution infrastructure through exposed cloud credentials. In the ConnectWise case, the access that mattered belonged to an application identity that tenants had consented to, not to any user. We covered the structural version of that risk in our analysis of a vendor cross account role on AWS, and the lesson carries over without edits.

The FBI says ARTEX lowers the bar for actors with minimal technical expertise, which matches what we saw earlier this year in a low skill attacker who used AI agents against 14 companies with bugs that already had patches. AI tooling does not need novel bugs. It needs volume, and the backlog supplies it.

How to detect an AI driven intrusion

The FBI says ARTEX generates high volumes of forensically noisy traffic that may trigger alerts, but attack speed leaves little time to respond before the objective is done. Detection here means catching the noise early and having a person read the alert within the hour, not the next morning.

The FBI's reporting request doubles as a detection checklist. Four signals stand out.

Bursts with iteration. The FBI describes compressed bursts of activity, high volumes of failed attempts with iterative, incremental changes, and multiple sub agents overwriting each other or sending duplicate requests. On a web tier that looks like sequential enumeration against login and search endpoints, and the FBI asks portals to alert on sequential lookups and unusually high numbers of records accessed per session.

Identity changes that no human requested. Credential additions to applications and service principals, new owners, new app role assignments and consent grants, privileged role assignments, and changes to Conditional Access. The FBI asks defenders to review successful and failed service principal sign ins separately, and to look for activity from outside expected vendor infrastructure without limiting the review to published IP addresses.

Cloud permission probing. Azure ARM deployment validation dry runs across many resource types, test blob writes and deletes with sub second timing, unusual Kudu or SCM API activity, unexpected IAM role assumptions and PassRole operations.

LLM egress from places that should not talk to LLMs. The FBI lists outbound calls to api.anthropic.com, api.deepseek.com, open.bigmodel.cn and api.x.ai, and asks about self hosted LLM gateways and resellers in egress logs. Treat this one with care. Your own staff call those endpoints legitimately. The signal is a server or web host making those calls alongside the other signs.

The KQL below covers the identity signal for Microsoft Entra in Microsoft Sentinel: credentials added to applications or service principals, joined against the same objects signing in from addresses they have not used in the previous 30 days.

Figure 02

New app credential, then sign in from new infrastructure

KQL

let lookback = 30d;
let window = 1d;
let credAdds = AuditLogs
| where TimeGenerated > ago(window)
| where OperationName has "Add service principal credentials"
    or OperationName has "Certificates and secrets management"
| extend TargetId = tostring(TargetResources[0].id), TargetName = tostring(TargetResources[0].displayName)
| extend Actor = coalesce(tostring(InitiatedBy.user.userPrincipalName), tostring(InitiatedBy.app.displayName))
| project CredTime = TimeGenerated, TargetId, TargetName, Actor, OperationName;
let knownIps = AADServicePrincipalSignInLogs
| where TimeGenerated between (ago(lookback) .. ago(window))
| summarize KnownIps = make_set(IPAddress, 500) by ServicePrincipalId;
AADServicePrincipalSignInLogs
| where TimeGenerated > ago(window)
| join kind=inner credAdds on $left.ServicePrincipalId == $right.TargetId
| join kind=leftouter knownIps on ServicePrincipalId
| where isempty(KnownIps) or not(set_has_element(KnownIps, IPAddress))
| summarize Attempts = count(), Failures = countif(ResultType != "0"), FirstSeen = min(TimeGenerated)
    by ServicePrincipalName, ServicePrincipalId, IPAddress, Actor, CredTime
| order by FirstSeen asc
A starting point to tune against your own telemetry, not a production rule. Review failed and successful sign ins separately, as the FBI advises.

The FLASH also lists IP indicators for three campaigns, but the FBI cautions that cloud hosted addresses get reassigned and should be treated as historical. Hunt with them in logs from 1 Oct 2026 onward; do not build blocking rules on them alone.

How we test for this on an engagement

The FBI's table is close to our own findings index across external, cloud and identity work. What it adds for a buyer is which of those findings an automated attacker now reaches first. Here is how that shapes a sanctioned engagement, at the level of approach.

We start wider than the scope document. On an external test, most of the time goes into discovery: every hostname, every certificate, every subsidiary's login page, every mobile backend we can tie to the organization. The portals the FBI names are usually missing from the asset list the client hands us. When we find one, we confirm it is theirs and in scope before touching it.

We treat every secret as a starting point, not a finding. A key in a JavaScript bundle or an old repository is reported, and then, within the rules of engagement, we answer the question that matters: what can it reach? Our secret exposure method and admin and debug endpoint checks are published on the Learn pages, and teams can check their own AWS policies for overbroad grants with our free AWS policy checker.

We measure chains, not counts. The number a report should carry after this alert is the count of steps from the least loved internet facing app to a privileged identity, and how long each step took us.

We test the identity layer the way the FBI describes the attacks. That means application and service principal permissions, consent grants, who can add credentials to which app, and whether those changes alert anyone. The Entra sign in and audit log review on our Learn pages covers the evidence we pull. On APIs we focus on object and function level authorization, the IDOR class the FBI lists, using the method in our API authorization checks.

We time the defenders. On adversary simulation work, with the client's agreement, we compress our own pace and record when the first alert fired, when a person looked at it, and when containment started. Three hours is now a planning number. If the first human review of an identity alert happens the next business day, the chain is already finished.

We do not run an autonomous agent swarm against a client estate. Speed can be simulated under control; uncontrolled volume against production has no place in a sanctioned engagement.

What is still coming

Expect more frameworks, not fewer. The FBI's sources include Google Threat Intelligence Group writing about ARTEX "and friends", and the FLASH itself is written to cover ARTEX and similar agentic frameworks. Taking one repository down did nothing to availability. Forks, mirrors, local variants and a commercial edition carry it forward, and the next tool will not need this one.

Expect model cost to keep driving model choice. The FBI says cheap models with weak guardrails dominate attacker use. Providers will tighten policy and attackers will move to whatever is cheapest and least restricted. Provider guardrails are not a control you own.

Expect speed to keep compressing. Under three hours is the fastest case the FBI cites today. It will not stay the fastest. The response that scales is to shrink the set of findings an agent can chain and make the identity layer loud when it changes.

What to do today

  1. Inventory the edges, then own them. List every internet facing app, including partner portals, mobile backends, employee tools and business unit builds, and give each one a named owner or a shutdown date.

  2. Re-rate the backlog for speed. Pull every open medium finding on an internet facing app and ask what it chains to. Exposed secrets, missing API authentication and IDOR go to the top.

  3. Take admin interfaces off the internet. Cloud consoles, Kudu and SCM endpoints, hypervisors, backup platforms and device management belong on trusted networks or dedicated admin paths, as the FBI recommends.

  4. Make application identity changes loud. Alert on credentials added to apps and service principals, new consent grants and privileged role assignments, and have a person review them the same day. The KQL above is a starting point.

  5. Rate limit what agents enumerate. Put limits and per session record ceilings on login, search and customer lookup endpoints, and alert on sequential access.

  6. If you ever authorized ConnectWise applications, follow the FBI's steps. Search by application ID, review sign ins from 1 Oct 2026, preserve logs before you change anything, and do not delete the enterprise app as a first response.