The FBI says attackers are using autonomous AI to compromise organizations in hours. Meanwhile, somewhere, a security ticket is still waiting for someone to assign it.

Remember when hackers actually had to sit at a keyboard and do all the work themselves?

Find a target.

Scan it.

Look for a vulnerability.

Try something.

Fail.

Try something else.

Get access.

Figure out what they compromised.

Move to another system.

Steal something.

Repeat.

For years, this required a certain amount of technical knowledge, patience, and occasionally the ability to troubleshoot a spectacularly broken Python script.

Now much of that work can be delegated to AI agents.

And unlike the people working in your SOC, those agents don’t need lunch, sleep, vacation, or a meeting to discuss whether the meeting should have been an email.

On November 13, 2026, the FBI released an advisory warning that malicious actors are using an autonomous penetration-testing framework called ARTEX to conduct cyberattacks at machine speed.

In some documented operations, attackers moved from initial targeting to privileged access in less than three hours.

Microsoft observed individual automated sequences completing dozens of actions in seconds.

And the FBI identified real-world campaigns involving financial institutions, cloud infrastructure, and third-party service providers.

FBI FLASH Advisory, November 13, 2026

Before anyone starts writing another article about Skynet taking over the internet, there’s an important distinction.

The AI isn’t independently deciding humanity needs to be hacked.

People are choosing targets, providing objectives, and deploying these systems.

The AI handles portions of the work.

That’s the change.

And it matters considerably more than whether the robots have developed malicious intentions.

First, What Exactly Is ARTEX?

ARTEX began as an open-source penetration-testing framework released in July 2026.

Its original purpose was legitimate security testing.

A security professional could give the system an objective, define a scope, and let AI agents perform reconnaissance and technical testing.

Instead of manually executing every command, the operator could describe what they wanted accomplished.

The framework would divide the objective among specialized agents.

One might enumerate assets.

Another might investigate a vulnerability.

Another could test available permissions.

Another could attempt to develop a working attack path.

Results were recorded and passed between agents so the system could decide what to try next.

ARTEX doesn’t contain its own AI model. It connects to external language models, which means operators can choose the model powering the agents.

The original developer removed the GitHub repository in October after reports that criminals were using it.

Unfortunately, deleting an open-source repository doesn’t delete every copy already downloaded.

Forks, mirrors, and modified versions remain available.

CERT-EU

There’s nothing inherently malicious about automating penetration testing.

Security professionals already use automation to discover weaknesses and validate controls.

The problem begins when the person giving the instructions doesn’t own the systems being tested.

And when those instructions involve stealing credentials, compromising applications, and extracting customer data, we’ve officially left the authorized-testing portion of the program.

The FBI Isn’t Warning About a Hypothetical Capability

This is what makes the November advisory significant.

We’re not talking about researchers demonstrating something interesting inside a laboratory.

The FBI, Microsoft, Google, and multiple independent security researchers have documented attackers using ARTEX in real intrusions.

The FBI identified activity across financial services, government, defense, technology, healthcare, manufacturing, energy, telecommunications, and other industries.

Microsoft separately attributed ARTEX-enabled activity to a China-state-aligned group it tracks as Storm-0940.

Google and Mandiant observed several different threat actors using ARTEX and similar agentic testing frameworks during incident-response investigations.

Microsoft Security

Google Threat Intelligence Group

Different attackers.

Different motivations.

Different targets.

Similar technological advantages.

The ability to automate large portions of an intrusion without requiring a human to execute every step.

And some of the results are already concerning.

South Korea: Thousands of People’s Information Exposed

One of the earliest documented examples involved financial institutions in South Korea.

CrowdStrike identified an attacker using ARTEX alongside several AI models to investigate and compromise financial-sector systems.

Zscaler ThreatLabz independently examined activity targeting applications used by financial organizations.

According to Zscaler, the campaign resulted in the exfiltration of personally identifiable information associated with approximately 67,000 individuals.

The attacker wasn’t necessarily breaking through the best-defended banking application.

Instead, the activity focused on peripheral systems.

Customer inquiry portals.

Employee-facing mobile application backends.

Web applications and APIs that may receive less security attention than a bank’s primary transaction systems.

Zscaler ThreatLabz

That distinction matters.

The broader South Korean financial sector experienced several breaches during this period, and investigators have not established that every incident involved the same attacker or ARTEX.

The approximately 67,000-person figure belongs to the campaign analyzed by researchers, not every financial-sector breach reported that month.

But the underlying pattern is important.

Attackers don’t necessarily need to compromise the application your organization spends the most money protecting.

They can look for the application everybody forgot about.

The employee portal built in 2019.

The mobile backend nobody has reviewed lately.

The supplier application running an old framework.

The API that returns slightly more customer information than it should.

Security teams have always known about those risks.

AI agents can now test them much faster and more persistently.

That’s the problem.

ConnectWise: One Trusted Application, Thousands of Potential Targets

The second example may be even more relevant to enterprise security.

In October 2026, ConnectWise disclosed unauthorized access involving application identities associated with its Cloud Backup service, formerly SkyKick.

Microsoft attributed related malicious activity to Storm-0940.

The attackers used ARTEX to accelerate attempts to access Microsoft 365 customer environments through compromised application credentials.

These weren’t necessarily attempts to steal each customer’s username and password individually.

The attackers were abusing an existing trust relationship.

A third-party cloud application had already been granted permissions inside customer environments.

Once attackers obtained access to the application’s credentials, they could attempt to use those trusted identities against customers.

Microsoft documented attempts to authenticate to more than 2,250 customer tenants.

Now, before that number becomes tomorrow’s terrifying LinkedIn infographic:

That does not mean 2,250 customers were successfully compromised.

It means the activity reached or attempted access across that many tenants.

In a separate password-spraying campaign against 327 accounts across eight organizations, Microsoft recorded more than 151,000 failed authentication attempts, with peaks exceeding 2,900 failures per minute.

That particular password-spraying activity produced no observed successful authentication.

But the compromised application identities were a different problem.

Microsoft confirmed follow-on activity in multiple customer environments, including reconnaissance, Microsoft Graph API operations, and attempts to modify application credentials and privileges.

Microsoft Security

ConnectWise disabled affected application connections and suspended certain services while investigating and containing the incident.

The company said it had no indication its Cloud Backup archive data had been compromised.

ConnectWise Security Advisories

The distinction between attempted access, successful authentication, unauthorized changes, and confirmed data theft matters.

We shouldn’t collapse all four into one scary statistic.

But the bigger lesson is straightforward.

A trusted third-party application can become an attack path into multiple organizations.

And AI automation can make exploiting that trust relationship considerably faster.

The Attacker Doesn’t Always Need a New Exploit

This is one of the things I find most interesting.

We’ve spent years talking about zero-day vulnerabilities.

Highly sophisticated malware.

Advanced persistent threats.

Exotic exploitation techniques.

And yes, those threats exist.

But much of the ARTEX activity described by the FBI involved things we’ve known about for years.

Weak credentials.

Exposed administrative interfaces.

SQL injection.

Command injection.

Missing API authentication.

Overprivileged cloud identities.

Poorly secured service accounts.

Misconfigured storage.

Trust relationships between organizations.

The FBI documented attacks involving everything from web shells and Kerberos abuse to exposed cloud publishing interfaces and unauthorized OAuth credential changes.

FBI FLASH Advisory

None of that requires an AI model to invent a new law of computing.

It just requires an attacker to find weaknesses that already exist.

What changes is how quickly those weaknesses can be discovered, tested, and combined.

An experienced penetration tester might spend hours understanding an unfamiliar application.

An agent can continuously probe it, examine responses, modify requests, and retry.

Sometimes it makes mistakes.

Sometimes it hallucinates success.

Sometimes the tools interfere with one another.

But it doesn’t get tired.

And it can keep trying.

The Most Interesting Metric Isn’t the Number of Attacks

It’s the amount of time defenders have to respond.

Google and Mandiant documented ARTEX execution bursts lasting roughly 2 to 25 seconds.

In one observed operation, researchers saw 27 events in just 23 seconds.

Another involved rapid testing of AWS permissions across security groups.

The system could encounter an error, modify its approach, and retry within seconds.

Google Threat Intelligence Group

Now compare that with the average enterprise security workflow.

An alert fires.

The SIEM processes it.

A ticket is generated.

The ticket is assigned.

An analyst investigates.

Someone requests additional logs.

The issue gets escalated.

Another team is consulted.

Someone asks whether there’s a change record.

Meanwhile, the attacker has already tested another dozen paths.

I’m not suggesting human security analysts are too slow.

I’m suggesting the attacker’s workflow is increasingly automated while the defender’s workflow may still depend on several humans coordinating across different systems.

That’s an architectural problem.

And it’s one worth solving.

The Good News: These Attacks Can Be Noisy

Here’s something that gets lost in the headlines.

Agentic attacks aren’t automatically stealthy.

In fact, several researchers found the opposite.

Google documented an ARTEX operation that generated approximately 240 application log events while attempting to exploit an exposed web service.

The AI agents repeatedly tried things, encountered errors, and sometimes interfered with one another.

Check Point Research found cases where ARTEX generated large numbers of findings that didn’t translate into successful attacker objectives.

In one cryptocurrency campaign, agents pursued hundreds of targets but failed to transfer funds into the attacker’s wallet.

Check Point Research

That’s worth remembering.

AI agents can be fast.

They can be persistent.

They can also be messy.

And that mess creates detection opportunities.

Rapid authentication attempts.

Sequential API requests.

Repeated permission testing.

Failed administrative actions.

Unexpected cloud-resource creation.

Large volumes of directory queries.

Unusual outbound connections.

Security teams can use those signals.

The challenge is recognizing them quickly enough.

First: Stop Exposing Things That Don’t Need to Be Public

This is probably the least glamorous recommendation in the entire FBI advisory.

And one of the most important.

Know what your organization has exposed to the internet.

Not just the main website.

Everything.

Partner portals.

Supplier applications.

Employee websites.

Mobile application backends.

Development systems.

Legacy services.

Cloud management interfaces.

Backup platforms.

Administrative APIs.

The random application someone built five years ago that still works, so nobody wants to touch it.

Especially that one.

The FBI recommends inventorying these systems and restricting sensitive administrative services to trusted networks, private connectivity, or dedicated management paths.

FBI FLASH Advisory

If a management interface doesn’t need to be available to the entire internet, don’t make it available to the entire internet.

That’s not revolutionary security architecture.

It’s just increasingly important when automated systems can continuously search for anything we leave exposed.

Second: Treat Service Accounts Like the Privileged Identities They Are

The ConnectWise incident highlights something I’ve been concerned about for years.

We spend enormous effort securing human identities.

MFA.

Conditional Access.

Privileged Access Management.

Identity verification.

Then we create an application identity with broad permissions and a credential that can remain valid for months.

Sometimes years.

And we call that automation.

The problem is that attackers love those identities.

They don’t necessarily require interactive authentication.

They can have access to multiple applications.

Sometimes multiple customer tenants.

And their actions may look legitimate because the identity itself has permission to perform them.

The FBI specifically recommends reviewing:

  • Application and service-principal credentials
  • New administrative roles and owners
  • OAuth consent grants
  • Unexpected permission assignments
  • Authentication from unfamiliar infrastructure
  • Privileged activity performed by non-human identities

For cloud environments, organizations should prefer managed identities, workload identity federation, and short-lived credentials over persistent secrets where supported.

Google and Mandiant

A service account shouldn’t have permanent administrative access simply because someone didn’t feel like maintaining a more restrictive permission model.

If compromising one application identity grants access across dozens of systems or customers, that’s a trust boundary worth fixing.

Third: Put Guardrails Around Business APIs

This one is particularly important because it doesn’t require malware.

Imagine an internal application that allows employees to search customer records.

The application is supposed to return one customer’s information at a time.

Now imagine an attacker discovers that changing an identifier returns someone else’s records.

Then another identifier.

Then another.

A human attacker might write a script to automate the process.

An AI agent can potentially discover the behavior, test the authorization boundary, and begin enumerating records with minimal guidance.

The FBI recommends server-side authorization and safeguards including:

  • Request and rate limits
  • Recipient limits for messaging systems
  • Transaction thresholds
  • Restrictions on bulk record retrieval
  • Monitoring for sequential record enumeration
  • Alerts for unusual API volume

Those are practical controls.

And they matter even when the requests use a valid account.

A user being authorized to view one customer record doesn’t mean they should be allowed to retrieve 50,000.

We need to stop treating successful authentication as proof that every subsequent action is legitimate.

Authentication tells you who is making the request. Authorization determines what they’re allowed to do. Behavioral monitoring helps identify when they’re doing something unexpected.

All three matter.

Fourth: Monitor the Cloud Control Plane

Cloud attacks often look different from traditional endpoint attacks.

There may not be a suspicious executable.

There may not be a malicious process.

There may not even be a traditional malware infection.

Instead, the attacker uses legitimate cloud APIs.

Create an identity.

Add credentials.

Assign permissions.

Access storage.

Create a virtual machine.

Read secrets.

Modify an application.

All through supported services.

The FBI documented ARTEX activity involving rapid cloud-permission testing, including attempts to determine what Azure and AWS credentials could actually do.

It also documented unauthorized creation of cloud resources and use of administrative interfaces for command execution.

That means security teams should monitor the cloud management plane as aggressively as they monitor endpoints.

Useful signals include:

  • New privileged identities
  • New service-principal credentials
  • Unexpected role assignments
  • Unusual cloud-resource creation
  • Rapid permission testing
  • Changes to application publishing settings
  • Bulk storage access
  • Unexpected access to secrets
  • New SSH keys
  • Administrative actions from unfamiliar locations

A new VM might be normal.

A new VM launched by a service account that has never created one, from an unfamiliar source, immediately after permission enumeration?

That’s worth investigating.

Fifth: Watch for Machine-Speed Behavior

This is where I think detection engineering needs to evolve.

Traditional security monitoring often focuses on known malicious indicators.

A suspicious IP.

A malware hash.

A known exploit signature.

Those still matter.

But AI-assisted attackers may use legitimate cloud services, valid credentials, common tools, and infrastructure that changes frequently.

The FBI specifically warns against blindly blocking every IP address appearing in its advisory.

Some addresses belong to cloud platforms or temporary infrastructure and may later be reassigned.

Instead, look at sequences.

An unfamiliar application identity authenticates.

It rapidly enumerates permissions.

It attempts access to multiple resources.

It modifies credentials.

It begins downloading large quantities of data.

It connects to an unfamiliar external destination.

That’s a very different story from one isolated API call.

Google recommends detecting sequences across identity, cloud control-plane, data-plane, endpoint, and network telemetry.

Google Threat Intelligence Group

The important question becomes:

Can we recognize the combination of behaviors while it’s happening, rather than reconstructing it during incident response next Thursday?

Sixth: Your Security Team May Need Automation Too

This is probably the largest operational change.

We cannot expect security analysts to manually investigate every automated attack attempt at the speed machines can generate them.

That doesn’t mean removing humans from security decisions.

It means using automation for actions that are safe, repeatable, and appropriate.

For example:

A new privileged identity appears unexpectedly.

It authenticates from an unfamiliar location.

It begins rapidly testing cloud permissions.

The security platform correlates those events.

A high-confidence policy temporarily restricts the identity or initiates an approved containment workflow.

The SOC receives one enriched incident instead of 47 disconnected alerts.

The analyst can investigate the meaningful problem rather than assembling the timeline from scratch.

That’s the direction I think security operations need to move.

Not autonomous systems making every security decision.

Automated detection and carefully controlled response, with humans retaining authority over consequential actions.

Because machine-speed attackers should not have an unlimited head start simply because the security team is waiting for someone to approve a ticket.

Seventh: Don’t Ignore Your Third Parties

If there’s one lesson from the ConnectWise incident, it’s that vendor trust is part of your attack surface.

Organizations depend on third-party applications for:

Backups.

Security monitoring.

Identity management.

Email.

Remote support.

Business operations.

Cloud administration.

And dozens of other services.

Those integrations often require powerful permissions.

Sometimes more powerful than anyone remembers granting.

That’s why the FBI recommends reviewing existing and previously authorized application relationships.

Not just the ones currently being used.

A disconnected vendor integration doesn’t necessarily mean every identity, credential, or permission associated with it has been removed.

And removing one compromised application credential doesn’t necessarily eliminate persistence created elsewhere.

For organizations that rely on MSPs or cloud service providers, the questions are straightforward.

What can this provider access?

What can it change?

Can its credentials be used from anywhere?

Would we know if those credentials were being abused?

Can we independently revoke access?

And how many systems or customers could one compromised identity affect?

Those are useful questions even if ARTEX disappears tomorrow.

What Would I Hunt for Today?

If I were taking this FBI advisory into a security operations meeting, I wouldn’t start by telling everyone to search for the word ARTEX.

I’d start with behaviors.

Identity: Look for unexpected service-principal sign-ins, new credentials, privileged role assignments, and authentication from unfamiliar infrastructure.

Applications: Look for rapid endpoint enumeration, unusual API request volumes, sequential record access, and repeated authentication or authorization failures.

Cloud: Investigate permission-testing bursts, new compute resources, unexpected storage access, and changes to management interfaces.

Endpoints: Examine new administrative accounts, web shells, unexpected SSH keys, suspicious command execution, and lateral-movement attempts.

Network: Look for unusual outbound data transfers, unexpected use of tunneling services, and connections from production servers to external systems they don’t normally use.

Business workflows: Monitor unexpected mass email or notification activity, large exports, and unusual transactions.

The FBI specifically identifies activity involving cloud metadata queries, Microsoft Graph, Kudu administration interfaces, abnormal API access, and unexpected communication with external AI services.

But here’s an important point.

A connection to an AI provider doesn’t automatically mean you’ve found ARTEX.

Plenty of legitimate applications connect to commercial AI APIs.

The useful signal is an unexpected connection combined with suspicious activity elsewhere.

Context matters.

Always has.

What About the 1,600 Exposed ARTEX Servers?

Here’s one of the more interesting findings from independent researchers.

On November 5, Check Point Research reported finding 1,608 live, publicly accessible ARTEX installations.

Censys reported 1,465 exposed hosts on November 4, with approximately 650 of them concentrated in two similarly configured hosting blocks.

Those figures came from different measurements and collection methods, so they shouldn’t be treated as contradictory measurements of an identical population.

Check Point Research

Censys

Not every exposed ARTEX server belongs to a criminal.

Some may be legitimate penetration-testing environments.

But Check Point found ten misconfigured instances exposing their databases.

That gave researchers access to operator sessions, objectives, and evidence of what the agents had been doing.

And the results were revealing.

In one campaign, ARTEX agents attempted to steal code-signing certificates from third-party services.

The agents obtained more than 300 certificates and associated passwords, but only three passed the checks necessary for the attacker’s intended use.

In another campaign, the agents recovered more than 190,000 gaming credentials, with sampling suggesting around 6,000 might still be usable.

Those are not numbers showing that every attempt succeeded.

They’re examples of the scale of automated discovery and collection researchers observed.

And in some cases, the attackers achieved surprisingly little despite enormous effort.

Which is worth remembering when somebody tells you AI-powered hacking is now unstoppable.

AI Doesn’t Make Attackers Infallible

This is the part where I think we need to resist the hype.

ARTEX is powerful.

But it isn’t magic.

The agents can make mistakes.

Misinterpret responses.

Repeat unsuccessful techniques.

Generate noisy logs.

Reach incorrect conclusions.

Interfere with one another.

In a cryptocurrency-theft campaign examined by Check Point, the operator tasked agents with pursuing hundreds of targets.

The agents reported some apparent successes.

But the researchers found no confirmed transfers into the attacker’s wallet.

The tooling had confused certain successful API responses with successful financial theft.

Check Point Research

That’s an important distinction.

An agent believing it compromised something doesn’t mean it actually did.

Just like an AI model confidently giving you an answer doesn’t make the answer correct.

Only in this case, the hallucination was part of a criminal operation.

Unfortunately, when the agents do find real weaknesses, they can exploit them quickly.

And because the operating cost of automated investigation can be relatively low, attackers may be willing to test enormous numbers of systems.

The economics are changing.

That’s what defenders should care about.

We Don’t Need an ARTEX-Specific Security Strategy

Please don’t take that as a product-development suggestion, cybersecurity marketing departments.

Someone is already preparing the slide.

“Next-Generation Autonomous AI Pentest Attack Prevention.”

Now with more dashboards.

But I don’t think the answer is to build a security strategy around the name of one attack framework.

ARTEX is one example.

Google has documented attackers experimenting with similar tools such as PentAGI, CAIRN, and other agentic frameworks.

Another framework will arrive.

Then another.

The model providers will change.

The orchestration software will change.

The interfaces will change.

The core problems won’t.

Exposed applications.

Weak authorization.

Excessive permissions.

Long-lived credentials.

Poor network segmentation.

Unmonitored APIs.

Insufficient cloud visibility.

Delayed incident response.

These are the weaknesses autonomous agents can exploit.

Fixing them has value regardless of which AI model happens to be driving the attack.

The FBI Just Gave Us a Pretty Useful Warning

Here’s where I land.

I don’t think the November 13 advisory is a reason to panic.

It’s a reason to review how our security programs operate.

The FBI, Microsoft, Google, Zscaler, Check Point, and CERT-EU aren’t describing a future possibility anymore.

They’re documenting attacks occurring today.

Some have resulted in significant data theft.

Some have enabled privileged cloud access.

Others have failed or produced noisy, unsuccessful attempts.

But together they show a meaningful shift.

Attackers can now delegate substantial portions of an intrusion to AI agents capable of working continuously and trying many paths in parallel.

That reduces the effort required to conduct attacks.

It can expand the number of organizations targeted.

And it can compress the time defenders have to respond.

What it doesn’t do is repeal the fundamentals of cybersecurity.

Least privilege still works.

MFA still matters.

Patching still matters.

Network segmentation still matters.

Secure application development still matters.

Monitoring still matters.

The difference is that leaving those controls incomplete may now become more expensive, much faster.

The Question I’d Ask Every Security Team

If I were reviewing this advisory with a SOC, I’d start with one question.

If an attacker begins testing our exposed applications and cloud identities at machine speed, how quickly can we recognize and stop the behavior?

Not:

Do we have a SIEM?

Not:

Do we have endpoint protection?

Not:

Do we have a firewall?

Those are components.

I want to know whether the security program can follow the entire sequence.

From the initial scan.

To the suspicious login.

To the permissions being tested.

To the new credentials.

To the unexpected administrative action.

To the data access.

To the attempted exfiltration.

And whether something can interrupt that chain before the attack achieves its objective.

Because we’ve spent years giving attackers access to automation through scripts, scanners, and offensive security frameworks.

Now we’ve added agents that can reason through errors and decide what to try next.

That’s a meaningful improvement in attacker capability.

But the defensive opportunity is still there.

Reduce what attackers can reach. Limit what compromised identities can do. Watch for abnormal sequences. And respond before the next step succeeds.

The FBI’s warning isn’t that we’re powerless against autonomous AI.

It’s that the time between an attacker discovering a weakness and exploiting it may be shrinking dramatically.

And if your response process still moves at the speed of a weekly change-control meeting, that’s probably worth fixing.

Because the hackers got AI agents.

Maybe it’s time we gave our defenders a little more help too.


Sources & Further Reading

  • The FBI’s November 13 FLASH describes ARTEX activity, documented attack techniques, indicators, and recommended mitigations. FBI
  • Microsoft’s October 21 investigation documents Storm-0940, the ConnectWise Cloud Backup compromise, attempted access across more than 2,250 customer tenants, and high-speed identity abuse. Microsoft Security
  • Google and Mandiant document agentic intrusion activity, rapid execution bursts, cloud identity abuse, and defensive recommendations. Google Threat Intelligence Group
  • Zscaler ThreatLabz investigates the South Korean financial-sector campaign and reported exfiltration involving approximately 67,000 individuals. Zscaler
  • Check Point Research examines actual ARTEX operator sessions, including code-signing certificate theft, gaming credentials, and failed cryptocurrency operations. Check Point Research
  • Censys documents exposed ARTEX infrastructure, misconfigured consoles, and overlap with other offensive tools. Censys
  • CERT-EU confirms observing activity consistent with ARTEX targeting its constituency and provides independent defensive recommendations. CERT-EU
  • ConnectWise’s Trust Center contains its investigation updates, affected application guidance, and containment recommendations. ConnectWise
  • Akamai examines why overlooked applications, API authorization weaknesses, and peripheral systems are attractive targets for automated attacks. Akamai