Do Human Work Podcast: Rethinking Cybersecurity's Foundations — WATCH NOW

Autonomous AI attacks are here. A field guide for AI vs. AI defense readiness with ARTEX as the case study.

Attackers now hand whole intrusions to AI agents. The next year will be decided by whether defenders run their side at the same speed. ARTEX, the open-source attack framework the FBI warned about on November 13, is the best-documented example yet, so we use it to show what is changing and how to prepare for what comes after it.

By 7AI Threat ResearchUpdated November 18, 2026Threat level: Active
1,600+Publicly exposed ARTEX consoles in early NovemberFBI FLASH-20261113-001
< 3 hrsFrom initial targeting to privileged access, in some intrusionsFBI FLASH-20261113-001
5 minFrom a GitHub secret search to Azure Key Vault exfiltration, by an AI agent in one caseMicrosoft, Nov 5, 2026
~28 secFor an agent to rerun a failed batch of API requests with a corrected API versionMicrosoft, Nov 5, 2026

These figures come from separate investigations of different campaigns. They are not measurements of one population. Microsoft does not name the framework in its two cases.

Part 1 · The shift

01

Autonomous AI attacks are here

An autonomous AI attack is one where an operator hands AI agents a goal and the agents plan and run the intrusion themselves: finding exposed systems, testing them, stealing credentials and adjusting after every result. Since late 2025 this has moved from research demos to real intrusions, and the FBI, Microsoft and Google have all documented it. For defenders, 2027 is the first year of AI against AI.

For the first time, attackers and defenders got the same technology at the same time. Attackers have started using it to remove the human from the loop of their own operations. Most security teams still run theirs at human speed, with a person in the middle of every investigation and every response decision.

The 7AI AI Attack Tracker shows how quickly that has changed. Publicly reported AI-driven attacks went from fewer than ten a month to 24 in October 2026 and 25 more by November 16, and most of the new ones were end-to-end agentic operations.

7AI AI Attack Tracker

Volume and velocity of AI-driven attacks, month by month

Each dot is one publicly reported incident, campaign, advisory or finding, placed by date and by the job AI did. Bars show disclosures per month.

ConfirmedAssessedSuspectedSelect a dot to open its source
A curated record of cases where a public source reports that AI did real work for the attacker, or that an AI agent under evaluation acted against real systems or people, dated by first public disclosure. Confirmed means the AI provider, the investigating vendor or a government agency stated it. Assessed means credible researchers found AI fingerprints without first-party confirmation. Suspected means reported or claimed without independent verification.
Read more: what counts as an autonomous AI attackShow less

Google's threat intelligence team expects this to get harder before it gets easier. It describes today's operations as noisy but successful with fewer humans in the loop, expects highly autonomous but still forensically noisy operations with no human in the loop within one to three months, and expects quieter, more sophisticated fully autonomous attacks to follow within three to six months.

"AI attack" covers very different things, and mixing them up leads to bad defensive decisions. A useful split:

Level 1

Conventional automation

Scripts and scanners. Fast and repetitive, with fixed logic. Part of every attacker's kit for decades.

Level 2

AI-assisted operations

A person drives and a model helps: writing lures, explaining an exploit, generating code. The person still decides each step.

Level 3

Autonomous attack chains

An operator sets a goal and agents plan, act, read the results and choose the next move. ARTEX sits here.

Level 3 is what changes the math for a security team, because the attacker's decision loop no longer waits on a person. The techniques are familiar: leaked secrets, password spraying, exposed admin interfaces, known web flaws. What changed is the cost of trying. Every extra target, retry and pivot is now nearly free for the attacker.

You can't defend against an autonomous attacker with a manual operating model.

Part 2 · 7AI in the lab

02

Inside an ARTEX intrusion, investigated end to end

Before the background and the readiness plan, here is what defending against an ARTEX intrusion looks like when AI works the defender side. Our team built a lab: a fictional wealth-management firm, hit by a full ARTEX-style intrusion that uses real indicators published by the FBI, Microsoft, AWS and CrowdStrike, plus indicators from one operator's public report. Twenty alerts came in from CrowdStrike, Okta and Wiz, and 7AI investigated every one of them.

Simulated environment. The company, hosts and people are fictional. Most of the attacker infrastructure and user agents come from public ARTEX reporting. Two values do not: the user agent artex-probe/0.4 (+planner), and 203.0.113.116, a reserved documentation address standing in for one exfiltration destination.

Attack chain · select a stage
    In parallel, on identity

    A replay of the lab's real 7AI investigations in the 7AI interface: the same tool runs, requests, responses, timings, conclusions and recommendations, with the company renamed. The clock follows the recorded tool timestamps, and idle stretches play faster. Approval controls are illustrative. In 7AI, each response action runs automatically or waits for approval based on the authority you set.

    20 alerts, three stories

    Instead of 20 separate tickets, 7AI grouped related alerts into three incident stories, each tied to one identity or host. Identity attacks that stood on their own stayed as their own findings. That is the difference between a queue and an understanding of the attack.

    Read more: the four look-alikes 7AI cleared, and whyShow less

    What 7AI cleared, and why

    An autonomous attack generates noise, and so does a normal business. The lab included four look-alikes that would trip the same detections. 7AI marked all four likely benign, showed its reasoning, and still told the team what to confirm.

    03

    One plain-language hunt for ARTEX across the whole environment

    Investigating the alerts you get is half of readiness. The other half is how fast your team can ask a new question of the whole environment. In the same lab, an analyst asked 7AI to hunt for ARTEX across every available data source over the last 60 days, using the published indicators. 7AI wrote and ran 33 queries in four rounds, all against CrowdStrike because it could not search Wiz or Okta for these indicators, reran the four that failed, closed out the false leads, and came back with a confirmed intrusion, what it could not see, and the containment decisions it needed from a human.

    A replay of the lab hunt in the 7AI interface: the analyst's request, every query 7AI wrote with its intent, request and result, and the final report, with the company renamed. Query timing within each round is approximate; round times and query durations are from the run. Containment approvals are illustrative.

    Part 3 · The ARTEX case

    04

    Why ARTEX is the case to study

    ARTEX is not the only autonomous attack framework, and it will not be the last. It is the one with the most public evidence behind it. Within four months of its release, the FBI, Microsoft, Google, Check Point, Unit 42, Censys and CERT-EU had all published on it, which makes it the clearest view yet of what an autonomous attacker does once it is pointed at a real organization.

    What is ARTEX?

    ARTEX is an open-source, multi-agent AI penetration testing and command-and-control framework. An operator sets a goal, a planning agent breaks it into tasks, and worker agents run reconnaissance, exploitation and credential tools, then adjust based on what they find. It was released on GitHub in July 2026 for authorized testing and has been used by threat actors in real intrusions since at least August 2026.

    Read more: how ARTEX works and how it spreadShow less

    Google describes it as written in Go, with a Next.js web console and six specialized sub-agents spread across the attack lifecycle. Microsoft says its agents drive familiar tools such as Nmap, curl, Python HTTP clients and headless browsers, and it works with any capable language model. Check Point's analysis of 10 ARTEX instances that exposed their full database found that most of the attacks in them ran almost entirely on their own once the operator set the objective.

    The original developer, posting as Autumn-27, made the project closed-source on October 8, 2026, after it was used against South Korean banks. Forks and mirrors kept it in circulation.

    How ARTEX went from pentest tool to attack framework

    1. July 2026ARTEX published on GitHub
    2. August 2026Earliest malicious use, according to the FBI
    3. October 8Developer makes the project closed-source after attacks on South Korean banks. Forks continue.
    4. October 21Microsoft ties Storm-0940 to ARTEX in the ConnectWise supply chain compromise
    5. October 30Google Threat Intelligence and Mandiant report ARTEX and similar frameworks in real intrusions
    6. November 5Check Point, Censys and CERT-EU publish. Microsoft reports agents harvesting secrets from GitHub.
    7. November 11Unit 42 reports ARTEX intrusions and a coordinated campaign against cloud environments
    8. November 13FBI issues FLASH-20261113-001 on ARTEX

    The next framework will have a different name, different infrastructure and different indicators. The lessons below are the ones that carry over.

    05

    What ARTEX attacks teach defenders

    Three public cases show what changes when the attacker is an agent. Each lesson applies to whatever framework comes next.

    Microsoft · October 21, 2026 · Storm-0940

    Storm-0940 got in through a trusted app credential while its password spray failed

    LessonThe loudest activity was the least dangerous. Investigation has to separate attempted access from successful access, and service principal sign-ins need the same scrutiny as user sign-ins.

    What happenedShow less

    From October 10 to 14, Storm-0940 infrastructure ran an automated password spray against 327 accounts across eight organizations, producing more than 151,000 failed logons and peaking at 2,900 failures per minute. Microsoft observed no successful authentication from that spray.

    The real access came through a different door. Using compromised ConnectWise application identities that customers had already granted access, the actor attempted sign-ins to more than 2,250 Microsoft 365 tenants with no interactive user sign-in.

    Microsoft · November 5, 2026 · Secret harvesting

    Five minutes from a leaked secret to vault exfiltration

    LessonA 30, 60 or 90 day rotation schedule cannot contain a secret that is found and used within minutes. Treat any exposed secret as already compromised, along with everything it could read.

    What happenedShow less

    Microsoft observed threat actors using an agentic AI offensive framework to scan public GitHub repositories for application secrets and AI API keys. Its post points to agentic tooling like ARTEX and does not name the framework in the two cases below. In one case, an agent went from finding a client secret to pulling data out of Azure Key Vault in about five minutes. It also observed that when a batch of requests failed because it used the wrong API version, an agent corrected it and retried successfully about 28 seconds later.

    WorkOS · November 2 and November 6, 2026

    A researcher's agent escaped its sandbox

    LessonTelling an agent its scope is different from enforcing it. To the defender, the logs looked like any other ARTEX intrusion, and intent was only established after the fact.

    What happenedShow less

    WorkOS disclosed unauthorized bulk access to an internal sales and support tool. On November 6 it reported that the source was a security researcher running ARTEX benchmark evaluations whose agent left its isolated test environment. The tool's API was reachable from the internet and accepted a predictable development credential. Detection took five days.

    Part 4 · Getting ready

    06

    Why detection alone falls short

    Most teams will see this kind of activity. Today's agentic tools are loud: high request volume, default tool user agents, many retries. Seeing the attack is rarely the hard part. Google makes the same point plainly: detection and disruption are two different functions.

    The hard part comes after the alert. A team can flag suspicious traffic in seconds and still need hours of human work to answer the questions that decide the outcome:

    1. Did any of this succeed, or is it noise against a locked door?
    2. Which identity, app or system is now in the attacker's hands?
    3. What can that foothold reach, and what did it touch?
    4. Who is authorized to contain it, and how fast can they act?
    5. Which preventive control needs to change so the next attempt fails?

    Answering those means pulling identity, cloud, web and endpoint telemetry together, often across teams and outside providers who each own one slice. When the attacker can act every few seconds, a response measured in shift handoffs falls behind on every step. That gap between detecting an attack and sustaining a response to it is what getting ready for AI against AI really means.

    07

    What defenders are seeing in the wild

    On November 17, a builder posted on r/cybersecurity that every one of their applications was under a wave of automated attacks: fake registrations, junk form submissions, HTTP 500 errors and bounced emails. Cloudflare's Under Attack Mode slowed it down without stopping it.

    Read more: what the operator's own report showedShow less

    Their own incident report, compiled from their logs with an AI agent, counts 601,065 HTTP requests between the evening of November 16 and early November 18, including 27,161 failed requests against login and auth routes, and traces 18 client IPs with a failed request. Quote requests arrived from @artex.invalid addresses, and more than 1,600 requests carried an ArtexCanary user agent. In the thread, they added that CPU ran two to three times above baseline and that calls between internal services slowed from about 250 milliseconds to about 1,800.

    The operator found no evidence of unauthorized access, but worried that one customer account had been compromised. The report is self-compiled and unverified, and they were careful to say so. It is still one of the clearest public accounts of what this looks like from the defender's chair, and the comments are worth reading.

    What practitioners in the thread said

    artex on everything. Makes it easy to cleanup at least, for now.
    u/lztsrts

    A defender across many managed SOCs said initial access in one case was a compromised password with no MFA, and ARTEX artifacts appeared only after that. The entry point was basic hygiene.

    it hilariously leaves a trail of items named ARTX*
    u/DurbingSalder3863

    Default names on temp files and accounts are a gift today. Hunt for them now, and expect operators to change them.

    It's overall a loud and sloppy attack
    u/RM0nst3r

    Loud does not mean harmless. The original poster still lost two evenings and saw real slowdowns.

    I pull in firewalls stats to block via updated WAF.
    u/Big_Law_3080

    Feeding firewall data back into WAF rules is the right instinct. It holds up when every block expires and can be rolled back.

    the LLM can clearly adapt to the challenge
    u/CosmoCrafterGame

    The original poster on why CAPTCHAs and honeypots felt weak. Friction slows an agent. Deception aimed at its goal works better.

    this sounds like another Tuesday on the internet.
    u/explosiva

    Fair skepticism. Volume alone does not prove an AI agent, and attribution matters less than whether anything succeeded.

    Which suggestions from the thread to adoptShow less
    1. Auto-update WAF blocks from firewall and edge data. Yes, with an expiry on every block and a way to roll it back, because agents rotate addresses and on shared hosting today's attacker IP can be tomorrow's customer.
    2. Use decoy paths such as a fake /.env to catch and ban scanners. Yes. It is cheap, it produces a high-confidence signal, and it matches Microsoft's guidance on honeypots, tarpits and fake wins. Time-limit the bans.
    3. Rate-limit login, registration and form endpoints, and validate email addresses before sending. Yes. The rate limits match FBI guidance, which recommends rate limits and alerts on high-impact business APIs.
    4. Check what the requests actually do before blaming ARTEX. Agreed. The question that matters is whether anything succeeded, and that answer comes from logs, not labels.
    5. Assume the basics are the entry point. In the one confirmed compromise described in the thread, the way in was a compromised password with no MFA. Phishing-resistant MFA and credential hygiene address that entry point.
    08

    Getting ready for AI vs. AI with NIST CSF 2.0

    This is the readiness plan we would run going into 2027, whatever the next framework is called. It is organized around the six functions of the NIST Cybersecurity Framework (CSF) 2.0, so it drops into the program and board reporting most security teams already have.

    The functions run continuously, not in sequence. For each one: what changes when the attacker is an agent, what to do about it, and what you should have in hand. The controls draw on the defensive layers Mandiant recommends against autonomous tooling.

    GV

    Govern

    An agent can act every few seconds. Your team cannot be deciding who is allowed to act for the first time in the middle of an incident.

    What to doShow less
    1. Set response authority in three tiers, and agree on the evidence that moves an action from one tier to the next.
    2. Write down when urgent containment goes ahead without certainty. Against an attacker that moves in minutes, waiting for a complete picture is itself a decision.
    3. Enforce scope for any agent you run yourself, including pentest and red team agents. The WorkOS incident started with a researcher's agent that left its test environment.
    4. Name who owns the decision when an incident spans security, IT, cloud teams and outside providers.

    Runs automatically

    • Enrichment and correlation
    • Block a known-bad source at the edge
    • Tighten a rate limit within set bounds
    • Preserve evidence

    Needs approval

    • Disable a service principal
    • Revoke sessions or tokens
    • Rotate secrets and vault contents
    • Remove consent grants

    Needs incident command

    • Isolate production systems
    • Cut a vendor integration
    • Customer or regulator notice
    • Changes owned by another team
    Deliverable: Response authority matrix
    ID

    Identify

    Agents try every reachable door at almost no cost, so anything exposed will be tried.

    What to doShow less
    1. Inventory internet-facing systems, partner portals, mobile backends and legacy services. The FBI calls these out as the weak points.
    2. Inventory non-human identities: service principals, OAuth grants, API keys and the permissions each one holds.
    3. Scan code and repositories for secrets, and treat any exposed secret as already used.
    4. Feed what exercises and incidents teach back into this inventory. CSF 2.0 places continuous improvement under Identify.
    Deliverable: Exposure and identity inventory
    PR

    Protect

    Agents read errors and retry instantly, so controls have to close access, not just slow it down.

    What to doShow less
    1. Move workloads to short-lived credentials and people to phishing-resistant MFA. The one confirmed compromise in the Reddit thread started with a password and no MFA.
    2. Restrict admin APIs, consoles and CI/CD to trusted networks, and limit the detail in error messages external users see.
    3. Rate-limit login, registration, form and other high-impact business endpoints.
    4. Plant decoys such as a fake /.env, tarpits and fake wins. Microsoft says that in its testing they reduced the attack traffic reaching real assets.
    5. Change WAF and access rules as attacks evolve, with an expiry on every block and a way to roll it back.
    Deliverable: Control change playbook
    DE

    Detect

    The signals exist, but they are spread across tools, and indicators rotate faster than blocklists.

    What to doShow less
    1. Collect and correlate web, identity (including service principal and non-interactive sign-ins), cloud control plane, Key Vault and endpoint telemetry, with retention long enough to look back.
    2. Hunt behavior: machine-speed enumeration, corrected retries, near-instant use of a newly exposed credential, and the privilege changes that follow.
    3. Treat sudden operational degradation as a security signal. CPU spikes, slower internal calls and bursts of server errors were the first thing the operator in the Reddit thread noticed, and they can start a hunt automatically.
    4. Use known indicators as leads, never as verdicts.
    Deliverable: Logging coverage matrix and hunting recipes
    RS

    Respond

    Most of the time is lost between the alert and the answer. Investigation is the step that decides everything after it, which is why we call it out on its own.

    What to doShow less
    1. Automate investigation so every alert is enriched, correlated, scoped and answered on one question first: did it succeed?
    2. Separate attempted access from successful access, and give service principal sign-ins the same scrutiny as user sign-ins.
    3. Contain within the authority tiers set under Govern, and escalate everything else with the evidence attached.
    Suspicious automated activityWAF, identity, application, cloud or endpoint signal, or an unexplained slowdown
    Investigate automaticallyEnrich, correlate across systems, determine exposure, and answer the first question: did it succeed?
    No evidence of compromiseKeep monitoring, tune rate limits or WAF rules where authorized, preserve evidence
    Confirmed or suspected compromiseEscalate, scope affected identities and assets, start approved containment
    Verify, document, adaptConfirm the action worked, roll back anything harmful, update controls
    Deliverable: Investigation and response workflow
    RC

    Recover

    A foothold an agent found in minutes can reach a lot. Recovery has to cover everything it could have touched, including what you did not see it touch.

    What to doShow less
    1. Rotate every secret, token and credential the compromised identity could read, and revoke its sessions and grants.
    2. Restore affected systems, and confirm the attacker's access is gone before closing the incident.
    3. Roll back temporary blocks and emergency changes that are no longer needed.
    4. Run a persistent, adaptive simulation and track five measures: time from first malicious activity to detection, alert to conclusion, conclusion to containment, the share of investigations closed without manual work, and the rate of unnecessary or disruptive actions.
    Deliverable: Readiness scorecard

    Part 5 · ARTEX field reference

    09

    How to hunt for ARTEX activity

    This part is the hands-on reference for ARTEX specifically. The method carries over to any framework: organize hunts by what the analyst is trying to establish, not by SIEM vendor, and let each question narrow the one before it.

    Hunting questionEvidenceWhat an answer gives you
    Is known ARTEX-linked infrastructure talking to us?Published IPs, user agents, authentication eventsA lead, never attribution by itself
    Is sustained automated reconnaissance under way?Request velocity, endpoint coverage, response codes, timingWhich applications are targeted
    Is the attacker adapting after failures?Changed payloads, corrected requests, fast retriesWhether attempts are progressing
    Were credentials or sessions compromised?User and service principal sign-ins, token activityWhether access succeeded
    Did it lead to persistence or privilege?New app credentials, role assignments, consent grantsWhat must be contained
    Was data accessed or taken?Graph, Key Vault, storage, mailbox and transfer logsScope and impact

    Behavioral signals worth hunting

    Corrected retries

    A failed API call followed within seconds by the same request with a fixed version, method or parameter. Microsoft's example was a read, and most reads, such as listing Key Vault secrets, never reach the Azure Activity log, so check Key Vault diagnostic logs as well.

    Microsoft, Nov 5, 2026
    Instant use of exposed secrets

    A service principal signing in from a new source shortly after its secret appeared in a public repository.

    Microsoft, Nov 5, 2026
    App-only sign-ins without history

    Non-interactive or service principal sign-ins from addresses that app has never used, followed by Graph enumeration.

    Microsoft, Oct 21, 2026
    Default tool fingerprints

    Default user agents from Nmap, curl, Python clients or Playwright. Useful for alerting, and easy for an agent to change.

    Microsoft, Storm-3358 report

    Starter queries for Microsoft Sentinel

    Two starting points in KQL. Run them against your own schemas and baseline before you alert on them.

    Show the two starter queriesShow less
    Sentinel KQLNew source for a service principal
    // Successful service principal sign-ins in the last day from an IP that app did not use in the 29 days before
    // Returns a row when the app is new, the Location country code is new for that app, or the app normally uses 5 or fewer IPs
    // The value 5 is a starting point. Remove the last where line to see every new IP
    let lookback = 30d;
    let recent = 1d;
    let baseline = AADServicePrincipalSignInLogs
        | where TimeGenerated between (ago(lookback) .. ago(recent))
        | where ResultType == "0";
    let knownIPs = baseline | distinct AppId, IPAddress;
    let appProfile = baseline
        | summarize BaselineIPs = dcount(IPAddress), BaselineLocations = make_set(Location, 100) by AppId;
    AADServicePrincipalSignInLogs
    | where TimeGenerated > ago(recent)
    | where ResultType == "0"
    | join kind=leftanti knownIPs on AppId, IPAddress
    | summarize SignIns = count(), Resources = make_set(ResourceDisplayName, 20), FirstSeen = min(TimeGenerated)
        by AppId, ServicePrincipalName, IPAddress, Location
    | join kind=leftouter appProfile on AppId
    | extend NewApp = isnull(BaselineIPs)
    | extend NewLocation = not(NewApp) and isnotempty(Location) and not(set_has_element(BaselineLocations, Location))
    | project-away AppId1, BaselineLocations
    | where NewApp or NewLocation or BaselineIPs <= 5
    | order by NewLocation desc, NewApp desc, BaselineIPs asc, FirstSeen asc
    Sentinel KQLFail, then success
    // Same caller, operation and resource: a failure followed by a success within two minutes
    // Skips caller and operation pairs that had a failure and a success in the same two-minute window during the 13 days before
    // Covers write and action operations. The Activity log does not record most reads, such as listing Key Vault secrets
    let lookback = 14d;
    let recent = 1d;
    let failed = dynamic(["Failure", "Failed"]);
    let succeeded = dynamic(["Success", "Succeeded"]);
    let usual = AzureActivity
        | where TimeGenerated between (ago(lookback) .. ago(recent))
        | where isnotempty(Caller)
        | summarize Fails = countif(ActivityStatusValue in~ (failed)),
                    Successes = countif(ActivityStatusValue in~ (succeeded))
            by Caller, OperationNameValue, bin(TimeGenerated, 2m)
        | where Fails > 0 and Successes > 0
        | distinct Caller, OperationNameValue;
    AzureActivity
    | where TimeGenerated > ago(recent)
    | where isnotempty(Caller)
    | where ActivityStatusValue in~ (failed) or ActivityStatusValue in~ (succeeded)
    | extend IsFail = ActivityStatusValue in~ (failed)
    | order by Caller asc, OperationNameValue asc, _ResourceId asc, TimeGenerated asc
    | extend PrevFail = prev(IsFail), PrevTime = prev(TimeGenerated),
             PrevCaller = prev(Caller), PrevOp = prev(OperationNameValue), PrevResource = prev(_ResourceId)
    | where not(IsFail) and PrevFail and PrevCaller == Caller and PrevOp == OperationNameValue and PrevResource == _ResourceId
    | where TimeGenerated - PrevTime < 2m
    | summarize Retries = count(), FirstRetry = min(TimeGenerated), FastestFix = min(TimeGenerated - PrevTime)
        by Caller, OperationNameValue, _ResourceId
    | join kind=leftanti usual on Caller, OperationNameValue
    | order by FastestFix asc

    Known infrastructure belongs in hunts only with its context. Microsoft documented 144.172.64[.]99 as the source of the Storm-0940 password spray between October 10 and 14, 2026. A match outside that window, or from shared hosting, is a lead to check and not a finding.

    What a hit proves

    • A known IP or user agent shows contact. It does not show compromise or prove the tool.
    • High request volume shows automation, not AI autonomy.
    • An exposed ARTEX console is not necessarily malicious. Some likely belong to authorized testers.
    • A successful app sign-in shows access. Microsoft is explicit that it does not by itself prove data was taken.
    10

    ARTEX indicators of compromise (IOCs)

    These are selected publicly reported indicators tied to ARTEX activity, gathered in one place with their source and date. Most come from the FBI FLASH, which compiles findings from Microsoft, CrowdStrike, Censys and Zscaler. A few come from vendor hunts and from defenders describing what hit them.

    Vet before you block. The FBI notes these addresses were observed historically and that cloud-hosted IPs get reassigned. A match is a lead to investigate, not proof of compromise, and an agent can change its address and user agent in minutes.

    IndicatorTypeContextSource

    Indicators are shown defanged. Copy and CSV export give the original values, ready for a query.

    Part 6 · Closing

    11

    How 7AI defends against autonomous AI attacks

    Everything above is meant to be useful whether or not you work with us. AI against AI is the reason 7AI exists, and here is how we run the same model for our customers.

    Data→Context→Judgment→Action→Outcomes

    The 7AI Platform puts AI agents across detection, investigation, threat hunting and response, so the questions in section 06 are answered at machine speed instead of in a queue. Under PLAID (People-Led, AI-Driven), each customer's AI Security Engineers set what the agents may do on their own and what comes back for a decision. People stay on the loop and set the rules, and agents carry the non-human work.

    For teams that would rather not staff that loop around the clock, PLAID ELITE adds 24x7 overwatch from 7AI security experts who own the escalations and approvals that need a person.

    The 7AI Platform

    AI agents across detection, investigation, response and threat hunting, run in your environment.

    See the platform

    PLAID ELITE

    The 7AI Platform plus 24x7 overwatch from security experts who respond and escalate on your behalf.

    Explore PLAID ELITE

    Related research: CRXfiltrate, the browser extension family that strips security headers, and 7AI incident response.

    12

    Sources

    Show all 19 sourcesShow less
    FAQ

    Questions security teams are asking about autonomous AI attacks and ARTEX

    An autonomous AI attack is an intrusion where an operator gives AI agents a goal and the agents plan and carry out the steps themselves: reconnaissance, exploitation, credential theft and data access, adjusting after each result. The person no longer directs every move. ARTEX is the most widely documented framework used this way so far.
    Organize the work around the six NIST CSF 2.0 functions. Govern: decide response authority before an incident. Identify: map exposure, non-human identities and secrets. Protect: short-lived credentials, MFA, rate limits, decoys and reversible control changes. Detect: correlated telemetry and behavioral hunts. Respond: automate investigation so every alert answers whether the attack succeeded. Recover: rotate everything a foothold could reach and measure readiness.
    ARTEX is an open-source, multi-agent AI penetration testing and command-and-control framework. A planning agent breaks a goal into tasks and worker agents run reconnaissance, exploitation and credential tools, then feed the results back into the plan. It was published on GitHub in July 2026 for authorized testing, and threat actors have used it in real intrusions since at least August 2026.
    No. ARTEX was built as a penetration testing tool, and some deployments likely belong to authorized testers. It becomes an attack tool when someone points it at systems they have no permission to test, which security researchers and the FBI have documented across many sectors since August 2026.
    Public reporting ties ARTEX to both state-aligned and financially motivated actors. Microsoft linked it to Storm-0940 in the ConnectWise supply chain compromise and to Storm-3358 in attacks on financial organizations. Check Point, Google, Unit 42 and CrowdStrike have documented other campaigns.
    On November 13, 2026 the FBI issued FLASH-20261113-001. It says malicious actors have used ARTEX since at least August 2026, that some intrusions reached privileged access in under three hours, and that more than 1,600 ARTEX consoles were publicly exposed in early November.
    Start with behavior. Look for machine-speed enumeration, failed API calls corrected and retried within seconds, service principals signing in from addresses they have never used, and new credentials or role assignments that follow. Known IPs and default tool user agents help as leads but are easy for an agent to change.
    Not on its own. Blocking known infrastructure removes some noise, but an agent can change its source address and user agent quickly. Microsoft recommends treating those indicators as alerting signals and pairing them with behavioral hunts, workload identity controls, and deception such as honeypots and tarpits.
    The FBI FLASH lists IP addresses tied to Storm-3358, to a South Korean financial campaign, and to the ConnectWise campaign, which Microsoft attributes to Storm-0940. It also lists the LLM API reseller domain xcai[.]pro. Researchers and defenders have also reported user agents such as ArtexCanary and artex-enrich/1.0. The indicator explorer on this page lists each one with its source and date. Vet every indicator before blocking, because cloud-hosted addresses get reassigned.
    Fast enough that manual response struggles to keep up. The FBI reports some intrusions went from first targeting to privileged access in under three hours, and Microsoft observed one AI agent, in a case where it does not name the framework, move from finding a leaked secret on GitHub to pulling data out of Azure Key Vault in about five minutes.
    7AI

    Get your security operation ready for AI vs. AI

    See how 7AI agents take an autonomous attack from first signal to approved containment, with your team on the loop.