Malicious actors are adopting AI the same way businesses are: to streamline operations, automate repetitive work, and accomplish more in less time. Unfortunately, their definition of productivity is considerably different from ours.
Everywhere you look, companies are talking about AI productivity.
Automate the workflow.
Eliminate repetitive tasks.
Connect specialized agents.
Reduce the time between identifying a problem and solving it.
Make the entire operation more efficient.
It’s the same pitch we’ve been hearing across the technology industry for the last few years.
And it turns out cybercriminals have been paying attention.
In November 2026, Google Threat Intelligence Group and Mandiant released research documenting how malicious actors are increasingly adopting multi-agent AI frameworks to accelerate cyber operations.
Not just asking a chatbot to write a script.
Not just using AI to compose a phishing email.
We’re talking about AI agents coordinating reconnaissance, vulnerability testing, exploitation, credential abuse, and other stages of an intrusion.
The underlying techniques aren’t necessarily new.
What’s changing is how those techniques are organized, automated, and executed.
And that may be one of the most consequential developments in cybersecurity this year.
Google Threat Intelligence Group
From AI Assistance to AI-Orchestrated Operations
There’s a meaningful difference between using AI as an assistant and building AI into the operating model.
We’ve all used AI to help with individual tasks.
Write some code.
Analyze a log.
Troubleshoot a problem.
Summarize research.
Now imagine connecting that capability to a collection of tools and allowing several specialized agents to collaborate.
One agent performs reconnaissance.
Another evaluates results.
Another investigates vulnerabilities.
Another determines which approach to try next.
Another records findings and shares them with the rest of the system.
The operator establishes the objective.
The agents coordinate much of the work.
And the process continues without requiring someone to manually direct every individual action.
That’s the direction offensive security automation is moving.
Google says it has now observed malicious actors using multi-agent penetration-testing frameworks during actual intrusions, including activity involving lateral movement, database exploitation, and preparation for data exfiltration.
Importantly, not every observed framework has demonstrated the same capabilities or achieved the same outcomes.
Some have been used in confirmed intrusions.
Others are being tested and adapted.
But the direction is clear.
Threat actors are beginning to incorporate AI into their operational infrastructure rather than using it only as a separate research tool.
ARTEX: A Real Example of AI-Driven Operations at Scale
ARTEX is probably the most widely documented example.
Originally released as an open-source penetration-testing framework, ARTEX coordinates AI agents and security tools to perform activities across an assessment.
An operator defines a target and an objective.
The agents plan tasks, execute tools, review results, adjust their approach, and document what they discover.
Those capabilities have legitimate uses in authorized security testing.
But attackers have also adopted them.
Microsoft documented a campaign involving a China-state-aligned threat actor it tracks as Storm-0940.
The attacker used ARTEX to accelerate activity associated with compromised ConnectWise Cloud Backup application identities.
The compromised application relationship allowed the threat actor to attempt access to downstream Microsoft 365 customer environments.
Microsoft observed attempts to authenticate to more than 2,250 customer tenants.
That doesn’t mean 2,250 organizations were successfully compromised.
In a related campaign, Microsoft recorded more than 151,000 failed authentication attempts, reaching a peak of approximately 2,900 attempts per minute.
Those password-spraying attempts produced no observed successful authentications.
But in other affected customer environments, Microsoft documented follow-on activity involving Microsoft Graph, directory reconnaissance, and modifications to application credentials and privileges.
The important lesson is the operational velocity.
The attacker combined compromised trusted access with automated testing and follow-through.
ARTEX wasn’t discovering an entirely new way to abuse identity systems.
It was helping an attacker execute familiar techniques across multiple environments with far less manual coordination.
And that’s where the operational advantage comes from.
What the Attackers’ Own ARTEX Consoles Revealed
Check Point Research provided an unusually useful perspective on November 5.
Instead of analyzing only activity observed on victim systems, researchers examined exposed ARTEX operator infrastructure.
They identified 1,608 publicly accessible, active ARTEX installations at the time of their investigation.
That doesn’t mean all 1,608 were malicious.
But ten misconfigured systems exposed databases that allowed researchers to inspect operator instructions and agent activity.
The findings were revealing.
In one campaign, an operator used ARTEX to target gray-market iOS signing services.
The agents worked through multiple targets, investigated vulnerabilities, and obtained more than 300 code-signing certificates and associated passwords.
Only three passed the checks needed for the operator’s intended use.
Another operator tasked agents with stealing cryptocurrency.
Across 292 objectives, 230 findings, and 400,791 agent messages, the operation generated substantial technical activity.
The attacker ultimately received $0 in the observed cryptocurrency wallet.
Some agents incorrectly interpreted successful API responses as evidence that funds had been stolen.
In another case, the agents identified and exercised a supply-chain write capability involving exposed cloud storage credentials.
Those examples illustrate both sides of the technology.
AI can coordinate enormous amounts of work with very little operator interaction.
But producing thousands of findings doesn’t guarantee the intended objective was achieved.
Agents can misunderstand results.
They can pursue dead ends.
They can report success when the real-world outcome is failure.
The important development isn’t that AI makes attackers infallible.
It’s that it allows them to run more operations, test more possibilities, and maintain activity at a scale that previously demanded considerably more coordination.
And even unsuccessful campaigns can expose sensitive information or create serious security incidents along the way.
CAIRN: Multiple Agents Sharing a Common Picture
CAIRN takes a different architectural approach.
Google describes CAIRN as an open-source, multi-agent penetration-testing framework using an OODA loop.
Observe.
Orient.
Decide.
Act.
If you’ve spent time around military planning or cybersecurity operations, that approach should sound familiar.
The system observes its environment.
Interprets what it discovers.
Chooses its next action.
Executes it.
Then evaluates the results and begins again.
CAIRN also uses a shared information structure called a blackboard.
Think of it as a common workspace where specialized agents can contribute findings and use what the others have discovered.
One agent doesn’t have to rediscover something another agent already learned.
That reduces duplicated effort.
It also allows the system to coordinate decisions across different phases of an operation.
Google reports observing CAIRN in real intrusion activity against targets including organizations in the U.S. aerospace sector.
Google Threat Intelligence Group
Google did not publicly establish that every targeted aerospace organization suffered a successful compromise.
But its observation matters because CAIRN is no longer simply a framework described in documentation.
It has appeared in actual malicious operations.
The interesting capability here is coordination.
A multi-agent system can collect information from different tools, maintain a shared understanding of the environment, and use that information to determine what to investigate next.
It’s the same workflow advantage organizations are pursuing with legitimate AI agents.
Just pointed at someone else’s infrastructure.
CyberStrikeAI: Bringing the Tools Together
CyberStrikeAI is another framework identified in Google’s research.
Its architecture is built around a Go-based backend that functions as both an orchestration server and a command-and-control component.
The framework connects language models to more than 100 security tools, along with custom scripts and reusable YAML workflows.
The value proposition is integration.
Rather than an operator manually moving between unrelated tools, the framework provides a central interface for coordinating tasks and interpreting results.
A model can potentially select an appropriate tool, evaluate the output, and choose the next action.
From an operational perspective, that’s useful.
It’s also exactly why malicious actors are interested.
Security tools don’t become malicious simply because they’re placed inside an AI workflow.
But when an attacker connects those capabilities into an automated platform, the result can accelerate multiple phases of an intrusion.
Google reports observing attacker experimentation with CyberStrikeAI.
That is not the same as establishing that CyberStrikeAI independently completed a successful end-to-end breach.
Google Threat Intelligence Group
That distinction matters.
The architecture demonstrates what the framework is designed to support.
The threat-intelligence observations tell us what researchers have actually seen malicious actors doing.
Both are relevant, but they shouldn’t be confused.
HexStrike AI: MCP Makes Offensive Tools Easier to Orchestrate
HexStrike AI brings another familiar technology into the picture.
Model Context Protocol, or MCP.
For anyone who hasn’t spent the last year watching every software company invent an MCP server, the concept is straightforward.
MCP provides a standardized way for AI applications to discover and invoke tools.
A model doesn’t need a completely custom integration for every individual capability.
The tools become available through a common interface.
That’s useful in legitimate enterprise automation.
It’s also useful for offensive security frameworks.
HexStrike AI connects AI clients to more than 150 offensive security tools.
Google describes an architecture involving specialized agents and callable functions covering:
- Reconnaissance
- Web application testing
- Exploitation
- Binary analysis
- Other security assessment tasks
The framework includes more than twelve specialized subagents.
Google Threat Intelligence Group
The important development isn’t that an AI model suddenly knows a new exploit.
It’s that the model can interact with a large collection of existing tools through a consistent interface.
The integration work becomes easier.
The workflow becomes more flexible.
And an agent can transition between tasks without requiring a human to manually connect every step.
Google has observed experimentation involving HexStrike AI.
Its earlier research also discussed HexStrike-related activity during incident-response investigations.
But the publicly disclosed evidence doesn’t justify claiming that every advertised feature has been used successfully in a real-world attack.
Again, the framework’s capabilities and demonstrated malicious outcomes are different things.
PentAGI: Autonomous Assessments With Memory and Planning
PentAGI is another example of this operational shift.
It’s an open-source, self-hosted penetration-testing platform designed to accept a target and an objective, then coordinate specialized agents to perform the assessment.
Its capabilities include:
- Task planning and execution
- A collection of professional security tools
- An isolated execution environment
- Web research
- Persistent memory
- Knowledge graphs
- Reporting and monitoring
The memory component is particularly interesting.
An agent can retain useful findings and reference information from earlier steps instead of beginning every decision from scratch.
PentAGI’s documentation describes integrations with both commercial and locally hosted AI models.
Google and Mandiant observed malicious actors using customized PentAGI-based orchestration systems between late August and early October 2026.
One actor used the framework for systematic reconnaissance and vulnerability scanning against organizations across Asia, including telecommunications providers and system integrators.
Most activity remained focused on asset discovery and vulnerability testing.
However, Google’s broader October investigation reported some operations that progressed into intrusion and persistence.
This is what makes PentAGI worth watching.
It reflects a move toward continuous, goal-oriented security workflows where tasks can be planned, executed, evaluated, and refined without someone manually coordinating every step.
Again, that has legitimate applications for defenders.
But malicious actors can use the same operational benefits.
Five Frameworks, One Common Direction
These systems aren’t identical.
They have different architectures, tools, orchestration models, and levels of demonstrated malicious use.
But they share a common direction.
Move more of the operational workflow from individual human actions into coordinated AI-driven processes.
For example:
A reconnaissance tool discovers an exposed service.
An agent interprets the result.
Another agent reviews the service for known vulnerabilities.
A test fails.
The system analyzes the error.
It selects another approach.
The results are added to shared context.
The workflow continues.
A human may supervise the process, provide new instructions, or approve consequential actions.
But the operator no longer needs to manually orchestrate every intermediate step.
That’s the real change.
The model isn’t necessarily creating a new exploit.
It’s coordinating work that would otherwise require more individual decisions, handoffs, and manual effort.
And those efficiencies can compound.
The Economics of Cybercrime Are Changing
One of the most important implications is economic.
Every attack has costs.
Infrastructure.
Tools.
Research.
Time.
Personnel.
Coordination.
Testing.
And the inevitable frustration of something not working the way it should.
AI can reduce some of those costs.
Check Point estimated that one ARTEX operator ran roughly two weeks of intensive activity against certificate-signing services using 36 billion tokens.
Based on the model pricing at the time, researchers estimated the inference cost at approximately $700 to $1,500.
Those figures represent estimated AI-model costs, not the full cost of the criminal operation.
But they illustrate why automated orchestration is appealing.
An attacker can invest in infrastructure, define multiple objectives, and allow agents to work through the tasks continuously.
Some operations fail.
Some generate false positives.
Others find real vulnerabilities.
At sufficient scale, the economics may still favor the attacker.
And that’s a more useful way to understand AI adoption in cybercrime than focusing exclusively on whether a model can independently invent sophisticated malware.
AI doesn’t need to make every attack successful to make the overall operation more productive.
Speed Is Becoming a Bigger Advantage Than Sophistication
Google and Mandiant repeatedly emphasize the speed of these workflows.
Agents can execute tool calls, inspect results, and change tactics in seconds or minutes.
Attackers can also run multiple operations simultaneously.
This changes the window available to defenders.
Imagine a vulnerable application exposed to the internet.
Traditional monitoring might detect suspicious activity and create an alert.
Then the alert enters an investigation workflow.
A security analyst reviews it.
Someone requests additional telemetry.
Another team checks whether a vulnerability exists.
A response is approved.
A change is scheduled.
Meanwhile, the attacker’s automated workflow may already have tested several additional paths.
That doesn’t mean human analysts are the problem.
It means the defender’s operating model may need to become faster and more integrated.
The attacker is reducing the time between discovery, testing, and action.
Defenders need to reduce the time between detection, understanding, and containment.
That’s the operational challenge.
Fortunately, More Automation Can Mean More Noise
Here’s the part that doesn’t get nearly enough attention.
Google explicitly notes that current agentic offensive frameworks frequently trade stealth for speed.
They generate a lot of traffic.
Repeated requests.
Rapid vulnerability testing.
Unusual API sequences.
Failed authentication attempts.
Reconnaissance activity.
Distinctive tool behavior.
And sometimes a remarkable number of mistakes.
Google Threat Intelligence Group
This creates opportunities for defenders.
An agent may test the same application repeatedly with variations of a request.
It may probe several interfaces in quick succession.
It may attempt access using an identity that normally behaves very differently.
It may rapidly enumerate cloud permissions.
It may create resources, modify credentials, and attempt to access data within a short period.
Each individual action may resemble ordinary administrative or testing activity.
But the sequence and velocity can reveal the problem.
The important question becomes:
Can your security tools recognize the pattern, or do they see dozens of unrelated events?
Because if the defender only sees individual logs while the attacker operates as a coordinated workflow, there’s a visibility problem.
Defenders Need to Think in Workflows Too
I think this is the biggest takeaway for security teams.
We don’t necessarily need another security product with “Autonomous Agent Defense” printed across the dashboard.
We need to improve how existing controls work together.
Start with the attack surface
Continuously inventory internet-facing applications, APIs, administrative interfaces, and exposed cloud resources.
Reduce unnecessary exposure.
Remove abandoned systems.
Prioritize vulnerabilities that can be exploited remotely.
Agentic frameworks can test what they can reach.
The less unnecessary exposure you provide, the fewer opportunities they have.
Restrict identities and permissions
Reduce standing privileges.
Use short-lived credentials where possible.
Require strong authentication.
Review application and service-principal permissions.
Monitor unusual credential creation, role assignments, and consent grants.
A compromised identity should not automatically grant broad access across an entire cloud environment.
Monitor behavior and velocity
Look beyond individual signatures.
Correlate rapid authentication attempts, API enumeration, failed authorization checks, unexpected privileged actions, and sudden changes in data access.
Build detections around sequences rather than isolated events.
Microsoft specifically recommends watching for high-volume requests and rapid variations of known techniques, noting that static user-agent strings or source IP addresses are easy for attackers to change.
Make containment faster
Not every security action needs to wait for a human.
High-confidence events can trigger predefined responses.
Temporarily restricting a compromised identity.
Blocking an obviously malicious session.
Quarantining an affected workload.
Disabling a newly created unauthorized credential.
The actions need careful design, testing, and appropriate approval boundaries.
But the principle is straightforward.
If the attacker can operate at machine speed, the defender shouldn’t need a committee meeting to interrupt every suspicious action.
Use AI to improve defensive operations too
AI-assisted triage, event correlation, enrichment, and investigation can reduce repetitive work for security teams.
But the point isn’t to replace analysts.
It’s to let them spend less time assembling evidence and more time making decisions.
Mandiant’s guidance emphasizes restricting privileged control planes, using short-lived identities, reducing exploitable attack paths, hardening applications, and monitoring behavioral volume and velocity.
Those are practical improvements regardless of which offensive framework happens to be popular next month.
We Shouldn’t Confuse Open Source With Malicious Intent
There’s another part of this conversation worth addressing.
ARTEX, CAIRN, CyberStrikeAI, HexStrike AI, and PentAGI are not inherently criminal simply because they have offensive security capabilities.
Authorized penetration testers, red teams, and security researchers need tools that test real weaknesses.
And autonomous testing can help organizations identify issues before attackers do.
That is valuable.
The same technology can be used for legitimate assessments or unauthorized intrusions.
The distinction is authorization and intent.
Google’s research demonstrates that malicious actors are adopting these capabilities.
It does not mean every deployment of these frameworks is part of a criminal campaign.
Nor does it mean every advertised capability has been demonstrated successfully in an attack.
We need to preserve those distinctions.
Otherwise threat intelligence becomes product marketing with a skull icon.
And cybersecurity already has plenty of that.
This Is a Workflow Transformation, Not Just a Technology Trend
The most important shift is how malicious actors are organizing their operations.
AI is becoming part of the process.
Not an occasional tool used for one task.
An operational layer that can coordinate multiple tools and actions.
The attacker defines objectives.
The agents divide the work.
The system executes.
Results influence the next decision.
And the workflow continues.
Sometimes the result is a successful intrusion.
Sometimes it’s an enormous amount of wasted activity.
Sometimes the agent claims success when nothing meaningful happened.
But the underlying operational model is changing.
And that’s what defenders need to understand.
The threat isn’t that every criminal now has an unstoppable digital superweapon.
It’s that the cost of testing, coordinating, and repeating attacks is falling while the speed and potential scale of those operations are increasing.
That makes existing security weaknesses more valuable to attackers.
An exposed API.
A forgotten web application.
An overprivileged service account.
A poorly monitored cloud control plane.
A vulnerability that remains unpatched for several weeks.
These are familiar problems.
Now they’re becoming easier to investigate and exploit continuously.
The Question Security Teams Should Be Asking
If I were discussing Google’s research with a security operations team, I’d start with this:
If someone begins probing our infrastructure with multiple coordinated AI agents, can we recognize the campaign as a whole before the individual actions become a successful intrusion?
Can we identify rapid reconnaissance?
Can we correlate repeated vulnerability testing?
Can we recognize unexpected privilege changes?
Can we connect cloud activity to endpoint and network telemetry?
Can we distinguish normal automation from malicious sequences?
And can we interrupt the activity quickly enough to matter?
Those are the questions.
Not whether we have a product labeled AI Security.
Not whether we recognize the name ARTEX.
Not whether a specific tool uses MCP, an OODA loop, or twenty specialized agents.
Those implementation details help us understand the threat.
The operational behavior is what we need to defend against.
The Attack Didn’t Change. The Workflow Did.
Here’s where I land.
Google’s research isn’t a warning that AI has suddenly invented an entirely new category of cybersecurity threats.
It’s evidence that malicious actors are adopting AI in the same way legitimate businesses are.
To increase productivity.
Reduce repetitive effort.
Coordinate specialized tasks.
Improve decision-making speed.
And operate at greater scale.
That doesn’t make the attackers smarter in every situation.
It doesn’t guarantee success.
And it doesn’t make traditional security controls obsolete.
But it changes how quickly attackers can move through familiar opportunities.
Which means defenders need to rethink how quickly they can identify and stop them.
We already know many of the controls that matter.
Asset visibility.
Least privilege.
Strong authentication.
Secure application development.
Network segmentation.
Cloud monitoring.
Behavioral detection.
Incident-response automation.
The challenge is getting those controls to work together at the speed the threat environment increasingly demands.
Because attackers are no longer just automating individual commands.
They’re automating the workflow around the attack.
And maybe that’s the real lesson.
Security teams need to stop treating each suspicious event like an isolated problem and start recognizing the coordinated operation behind it.
The attackers are connecting their tools.
It’s time our defenses did a better job of connecting the dots.
Sources & Further Reading
- Google’s November 16 AI Threat Tracker documents observed malicious use of ARTEX, CAIRN, PentAGI, and experimentation with CyberStrikeAI and HexStrike AI. Google Threat Intelligence Group
- Google and Mandiant’s October 30 report provides additional details on real-world intrusions, operational maturity, and defensive controls for multi-agent offensive frameworks. Google and Mandiant
- Microsoft documents Storm-0940’s ARTEX-enabled operations, ConnectWise application-identity abuse, and high-speed authentication attempts. Microsoft Security
- Check Point Research provides direct visibility into ARTEX operator consoles, observed campaigns, autonomy, successes, and limitations. Check Point Research
- PentAGI’s documentation explains its authorized penetration-testing architecture, agents, memory, tools, and execution model. PentAGI
- Microsoft documents how agentic offensive frameworks generate recognizable behavioral patterns, including rapid testing, retries, and programmatic access to exposed secrets. Microsoft Security
