AI Agent Frameworks Accelerate Familiar Cyberattacks

Oct 30, 2026 338 views

By Aurora Blum, David Mainor, Rohit Nambiar, Omar ElAhdan, Matthew McWhirt, Will Silverstone, Bhavesh Dhake, and Chris Busse

AI agents are speeding up familiar attacks

The important shift in recent intrusions isn’t that attackers have discovered new weaknesses. It’s that agentic frameworks can test and exploit familiar ones at a pace that changes how quickly a breach can unfold. For defenders, the pressure comes from software that can pursue several paths, recover from errors, and keep working with little human direction.

In its September 2026 report, Google Threat Intelligence Group (GTIG) said some forward-leaning adversaries were moving from simple prompts to agentic workflows and LLM-enabled automation. Since then, GTIG and Mandiant have encountered actors using the open-source pentesting frameworks ARTEX, Hexstrike, and CAIRN during incident response investigations. A Wiz report has documented related activity. Taken together, these cases point to growing use of open-source, multi-agent offensive platforms and possibly custom-built agent harnesses.

Here’s the thing: the underlying work remains recognizable. Attackers still use stolen credentials and target unpatched systems. What changes is how quickly a framework can link those steps together and try alternate routes. That can turn a complex intrusion into a machine-paced operation, raising the potential speed and scale of attacks. The defensive measures discussed here—isolating control planes, using short-lived credentials, enforcing least privilege, segmenting networks, and detecting behavior—are established security practices. The challenge is applying them against software that can act at scale.

Agentic frameworks in active intrusions

Attackers have long repurposed tools built for security teams. Cyber espionage and financially motivated groups have used platforms such as Cobalt Strike and Metasploit for years. LLM-powered offensive frameworks extend that pattern: they coordinate agents using open-source or frontier models to automate parts of a penetration test and, increasingly, real intrusions. These tools have been available in the wild for some time; what matters now is evidence that they’re succeeding in live operations.

Since late August 2026, Mandiant incident response teams have observed actors using ARTEX, PentAGI, CAIRN, and potentially custom harnesses. Research telemetry supports those observations. In some incidents, agents handled substantial parts of the attack lifecycle, including lateral movement, database exploitation, and preparation for data theft. They could explore multiple paths, troubleshoot failures, and reach objectives in seconds or minutes. That’s a meaningful change in operational tempo, though the available evidence doesn’t explain how consistently these systems succeed across different environments.

ARTEX: from open-source project to widely reused tool

ARTEX is a Go-based, autonomous multi-agent platform for LLM-driven penetration testing and offensive command and control (C2), with a Next.js web console. It was created by the GitHub user Autumn-27. Its creator removed the original repository in October 2026 after widespread abuse, but community forks continue to circulate globally. These include localized variants such as ScopeWeaver and a commercial offering called ARTEX PRO.

The framework divides an attack lifecycle among six specialized sub-agents. Using APIs from frontier and open-source models, it turns broad tactical goals into machine commands. GTIG has observed ARTEX conducting automated Active Directory reconnaissance, escalating privileges, profiling cloud infrastructure—including harvesting Azure storage keys—and creating and deploying custom webshells.

ARTEX has attracted actors with different motives since late August 2026, from extortion groups to suspected cyber espionage operators. Wiz Research has tracked an ARTEX-linked campaign that GTIG calls UNC7228, overlapping with activity Microsoft attributes to the PRC-nexus actor STORM-0940. Wiz’s research extends its account of the campaign beyond the October activity focused on IT, tracing operations back to at least August 2026. The campaign targeted and compromised organizations in the US and Europe, stealing data from enterprise software, industrial automation, semiconductor manufacturing and design, and telecommunications companies.

The pace stands out. In these operations, the actor typically moved from the first compromised account to deep system access in about four hours; one case took as little as 15 minutes. The actor also tailored tools to victims’ environments and switched to open proxies when initial infrastructure was blocked.

GTIG and Mandiant have seen other actors use ARTEX after gaining access, including for reconnaissance, lateral movement, and privilege escalation. Some financially motivated groups used it to support data-theft extortion; investigators also identified additional suspected PRC-nexus clusters. The affected organizations spanned government, technology, chemicals and materials, and manufacturing in the US. Separate public reporting describes ARTEX targeting the financial sector in Asia.

What the activity looks like in logs

In several cases, attackers supplied ARTEX with compromised credentials and directed it to continue through later attack stages. The resulting activity can look different from work by a human operator: execution arrives in short, dense bursts, and repeated attempts can leave a noisy trail.

  • Log timestamps showed bursts lasting roughly 2 to 25 seconds, despite longer pauses between operational phases. In one operation, ARTEX generated 27 events during 23 seconds of active execution while rapidly probing AWS permissions across security groups. When a script was too large, the framework trimmed it and tried again, successfully deploying a 17-snapshot instance in about 10 seconds.
  • In another case, ARTEX used valid credentials to access an internet-facing Linux Weaver OA web server and issue SQL commands through exposed application APIs. It achieved partial command execution and continued reconnaissance, but the iterative process generated 240 log events. Some errors may have resulted from multiple sub-agents overwriting one another as they pursued the same goal.

The database activity shows how that trial and error unfolded. ARTEX tried to move from database execution to system execution by using an application-specific SQL API available to the supplied account. It attempted to write MySQL logs with a .jsp extension into publicly accessible locations, apparently aiming to turn those logs into web-accessible JSP webshells.

It set general_log_file = '<path to webshell>' and enabled logging with SET GLOBAL general_log = 1. Subsequent SQL commands went to the path named by general_log_file. ARTEX then issued SELECT statements in the form SELECT '<% [webshell content] %>'. Because the Java web servlet parses and compiles Java code inside JSP tags, the approach could place executable code in the process memory space.

Logs show repeated attempts with temporary, incrementing-looking filenames: cl1217.jsp, f1219a.jsp, and z1219.jsp. Each webshell candidate ran a different command. Errors such as variable ‘t is already defined caused attempts to fail and likely prompted ARTEX to revise its code. Some later webshells corrected earlier errors and returned valid command output.

In a separate access-probing operation, the framework created files with different extensions and names matching artex-probe-*, where the asterisk represented a five-digit number that appeared to increment. The researchers couldn’t determine exactly what the numbers meant or how they advanced. Similar numeric markers appeared in dropped filenames, account names, passwords, and email subjects.

Observed ARTEX activity across the attack lifecycle

Phase of the attack lifecycle Observed ARTEX capabilities and tradecraft
Initial reconnaissance
  • Mapped the effective permissions of obtained Azure credentials—including SAS tokens, service principals, Kudu credentials, and Storage Account keys—using sub-second checks, test blob writes and deletes, and ARM deployment validation dry runs. ARTEX wrote and deleted a small test blob in about 330–400 milliseconds, and ran an eight-second deployments/validate sweep across 11 Azure resource types.
  • Tested compromised IAM user permissions with DryRun flags and placeholder IDs to assess EC2 compute, EBS volume, and snapshot capabilities.
  • Made more than 500 web requests, probing filenames and extensions across web directories. The response codes, including 200 and 403, could help identify which endpoints the server allowed it to access.
Establishing a foothold
  • Abused Kudu administrative APIs to run arbitrary commands and stage custom Python, C#, and malicious PowerShell scripts.
  • Used native curl to download dynamically generated PowerShell and batch scripts onto a victim’s internal Windows database server, then sent command results back through 491 rotating webhook.site URLs to establish C2 and execute commands.
Privilege escalation Further observations are not included in this fragment.
Privilege escalation in this campaign followed two paths: a cloud permissions check that appears to have failed, and a series of successful moves through identity systems and databases. The contrast matters. Automated tooling can make an attack broad and fast, but access still depends on the permissions and weaknesses it finds.

From credential theft to persistence

The operators tried to launch cloud compute instances with high-value IAM roles so they could retrieve temporary credentials. Those attempts appear to have failed because the instance profile ARNs were invalid. Elsewhere, they ran Kerberoasting scripts to collect service tickets across compromised domains, dumped database credentials through SQL injection, and, after pausing to crack credentials offline, used DCSync scripts to steal the domain krbtgt key, cloud AD-sync credentials, and domain controller machine hashes. They also found a writable admin flag and created accounts with `is_admin=true` within minutes. That’s a stark reminder that privilege escalation can hinge on a small application flaw, even amid elaborate credential theft. Internal reconnaissance was extensive. The operators repeatedly generated PowerShell enumeration scripts and ran them against a domain controller and federation server. They checked which domain usernames could be validated without pre-authentication, listed Group Managed Service Accounts, reviewed Active Directory Certificate Services templates named SmartcardUser and ClientAuth, and mapped thousands of cross-forest security principals. They also swept internal Exchange, the PasswordState credential vault, and SSRF/SCM targets. Attempts to move laterally onto domain controllers used Pass-the-Ticket, WinRM, Kerberos relay, and Pass-the-Hash scripts. The effort ran into local Windows service token privilege restrictions. Endpoint protection then blocked execution, and defenders cut off access to the server. Persistence continued through both cloud infrastructure and user accounts. The operators generated an SSH key pair and allocated a dedicated public Elastic IP. They couldn’t create a custom security group because of permission limits, so they launched persistent `t3.micro` instances using existing groups, apparently to create an externally reachable jump host and an internal foothold. They also took over accounts by resetting identified users’ passwords, created multiple accounts with plaintext passwords—including names using `ArtexProbe`—and added administrator accounts.

Data collection through familiar features

The activity extended well beyond access and reconnaissance. Operators queried backend SQL databases, collecting about 400 KB of results across roughly 20 queries, and performed mass blob reads. They also enumerated more than 110,000 Active Directory objects from a domain controller and retrieved the Domain Admins group. Command output was sent to rotating webhook.site endpoints using curl. Other collection attempts targeted stored notes and their attachments: the operators ran queries to decrypt notes and tried to read attachments belonging to other users. They created a 100 GB volume and expanded launched instances’ root disks to 60 GB, steps that appear to have prepared for data exfiltration through automated collection scripts. Custom boot scripts on temporary, keyless EC2 instances may also have been used to harvest data from mounted EBS snapshots and volumes. One operation stands out for its use of ordinary application features. The operators edited an employee record in a legacy database, created and deleted notes and status rows, and pointed checklist responses to their own probe file. They then used the application’s notification system to send test emails to more than 1,300 internal users, turning a trusted channel into a mass-messaging mechanism. Afterward, they sent test emails to individual recipients. The point is easy to miss: attackers don’t always need custom malware when an application already provides a way to reach users at scale.

PentAGI moves beyond scanning

GTIG also observed real-world use of PentAGI, an autonomous offensive framework developed by VXControl. Its open-source and commercial editions are designed to let a user specify a target and objective, then have specialized agents divide the work into “Flows,” carry out subtasks, and report results. PentAGI runs its tools and commands in isolated Kali Linux sandboxes rather than on the host. Its toolset draws on open-source Kali utilities such as Metasploit, nmap, and SQLmap, and it supports more than a dozen cloud and local LLM backends, including frontier and open-weight models. Most observed activity remained at WHOIS-based asset mapping or active vulnerability scanning. But operational artifacts point to some intrusions and persistence across multiple organizations. Operators are also adapting the framework: GTIG identified a customized orchestration platform built on PentAGI’s open-source version, likely used from at least late August through early October 2026 for systematic reconnaissance and vulnerability scanning across organizations in Asia, including system integrators and major telecommunications firms. In another case, PentAGI was combined with proxy services to target the aerospace sector. That gap between routine scanning and active intrusion is more significant than it looks. PentAGI can lower the skill needed to coordinate complex campaigns, but the evidence here doesn’t show that most users have reached that level.

How LLM-assisted attacks are changing

GTIG describes a rapid progression in adversarial use of LLMs: from generated code and dynamic malware to poisoned agent-harness files and multi-agent offensive frameworks. Between late 2025 and October 2026, the shift crossed an operational threshold: multi-agent systems began carrying out real intrusions. GTIG sees this as an early stage, with open-source tools often used in broad, noisy campaigns that can still succeed. A fully autonomous operation would leave the human to specify a target and objective, then wait for the system to deliver the result. The stages below trace that progression and GTIG’s near-term expectation: **Stage 1: Prompt-based use of LLMs.** Adversaries use chatbots to write or debug malware, draft phishing messages, create personas, and perform basic target reconnaissance. They delegate simple, low-risk tasks that are easy to check or correct. GTIG places this stage between the end of 2025 and early 2026. [Its earlier reporting covers this period](https://cloud.google.com/blog/topics/threat-intelligence/adversarial-misuse-generative-ai?e=48754805). **Stage 2: LLM capabilities embedded in malware.** Malware such as HONESTCUE and PROMPTSPY can call on LLMs during execution to generate code or vary payload obfuscation in attempts to evade defenses. This brings LLM use into post-intrusion activity. GTIG dates this stage to early 2026. [Related analysis examines this shift](https://cloud.google.com/blog/topics/threat-intelligence/distillation-experimentation-integration-ai-adversarial-use?e=48754805). **Stage 3: LLM-enabled automation in operations.** Agents take on discrete tasks such as setting up or debugging malware development environments, while human operators use them to develop exploits and support high-stakes vulnerability research. Operators also become more attentive to operational security and use LLM proxy services to hide their activity. The human remains involved in consequential decisions. GTIG places this phase from early 2026 through September 2026. [Its reporting follows the move from prompting toward autonomy](https://cloud.google.com/blog/topics/threat-intelligence/from-prompting-to-autonomy-the-evolution-of-adversarial-ai?e=48754805). **Stage 4: Autonomous framework development and testing.** Campaigns hand more parts of the attack lifecycle to LLM-assisted tools, with model APIs built into tools and Telegram bots that can act autonomously. GTIG dates this experimentation to mid-2026 through September 2026. [The same analysis tracks this development](https://cloud.google.com/blog/topics/threat-intelligence/from-prompting-to-autonomy-the-evolution-of-adversarial-ai?e=48754805). **Stage 5: LLM-driven tooling handles multiple stages in live attacks.** Agents now carry out a substantial portion of some mass-exploitation campaigns with limited human input, and some malware has more autonomous capabilities. Threat actors continue testing ways to obscure their use of LLMs, including mixers, inference services, and local models. The tactics remain messy and noisy, yet successful. GTIG describes this as the current stage. **Stage 6: Multi-agent attacks with little or no human involvement.** In GTIG’s near-term projection, operators will set the target and objective while multi-agent frameworks run the full attack chain and return results. The operations may be highly autonomous but still unsophisticated and forensically noisy. Threat actors are expected to diversify their infrastructure and tools, making activity harder for defenders to see. GTIG puts this stage one to three months away. **Stage 7: Sophisticated, fully autonomous attacks.** This is the next stage in the framework’s progression.

Autonomy is the next step

The next stage of offensive AI would make attacks less dependent on human operators and harder for defenders to observe. In GTIG’s assessment, that could mean fully autonomous intrusions, paired with stealthier methods such as obscure infrastructure or self-hosted language models. The projected timeframe is medium-term: three to six months.

There are already signs of experimentation. GTIG has observed threat actors testing the ZeroHollow inference service and AgentZero, a fully agentic framework. The evidence points toward continued efforts to move from assisted operations to autonomous use; it doesn’t establish how quickly those efforts will succeed.

More speed, with a visibility tradeoff

Over the past year, GTIG has tracked a shift from using LLMs for ad hoc productivity to building coordinated, multi-agent offensive frameworks. Earlier research described early interest in agentic AI. More recent incident response work and proactive intelligence collection show adversaries using these systems to automate specific tasks and phases of intrusions. Generative models can help them work faster and at greater scale, while agentic capabilities support more complex attack infrastructure.

ARTEX illustrates the tradeoff. It can compress attack timelines to machine speed, but its unrestricted execution can leave forensic traffic, recognizable identifiers, and code traces that defenders can detect. That makes such tools more suitable when detection carries little cost. And detection alone doesn’t stop an attacker from achieving an objective: identifying an intrusion in time and disrupting it are separate jobs.

GTIG assesses with high confidence that cybercrime groups will keep adopting autonomous offensive tools. Wider campaign reach may make up for lower success rates. Operators focused on stealth and long-term access are less likely to use public versions, though they may still turn to them when speed or scale matters. For a broad range of actors, low cost, easy integration of new exploits, and the ability to scale make these frameworks an attractive force multiplier. GTIG expects adoption to increase in the near term.

Defenses need to limit what valid access can do

LLMs don’t fundamentally change attackers’ techniques; they shorten the time it takes to combine them. Credential discovery, permission testing, lateral movement, and data access that once took hours can happen in minutes. These actions often use legitimate identities and supported features, which static indicators may miss.

The practical response is to make each compromised identity or workload less powerful. Limit exposure of management interfaces, replace long-lived secrets with short-lived credentials scoped to specific needs, segment application tiers, and add safeguards to high-impact business functions. Behavioral detection can catch activity these controls don’t block, but it depends on having enough identity, control-plane, data-plane, and network telemetry to establish normal patterns. These are familiar defensive measures; the difference is that automated tools can find and exploit gaps between them much faster.

Autonomous tools can identify weaknesses, test access, interpret errors, change tactics, and continue along an attack path with little human input. Tasks that once required hours of investigation, code changes, troubleshooting, and operator decisions may now take minutes. That speed also complicates detection: attackers can use valid credentials, normal management APIs, supported cloud storage protocols, and existing administrative interfaces. Tool names, hashes, and IP addresses remain useful when present, but they won’t cover much of this activity.

Effective defense therefore depends on two things: controls that restrict what an attacker can do with valid access, and telemetry that reveals when an identity, application, or workload starts behaving outside its usual pattern.

What changes in the attacker timeline

Investigations of LLM-enabled and highly automated attacks repeatedly surface four patterns:

  • Speed and scale: Automated tools can scout broadly, test multiple paths at once, respond to errors, and continue into follow-on activity. The time from initial access to privilege discovery, lateral movement, and data access can shrink sharply.
  • Connected environments: An exposed internet-facing application may reveal credentials in a configuration file. Those credentials could open access to cloud storage, source repositories, identity systems, or internal infrastructure. Automation makes it easier to find and test these connections quickly.
  • Activity that looks legitimate in isolation: A service principal signs in, an API gets called, or a storage object is downloaded. The stronger signal may lie in context: the request’s origin, its volume, surrounding activity, and whether it fits that identity’s normal role.
  • Gaps in control-plane and data-plane monitoring: Many organizations monitor endpoints more closely than management APIs, programmatic identities, and cloud storage. Permission checks, storage key retrieval, bulk downloads, firewall changes, and management API calls may be logged without producing useful alerts.

Mandiant recommends organizing enterprise defenses into five foundational layers to restrict lateral movement and reduce the speed advantage of autonomous tools.

Source: Google Threat Intelligence Group · cloud.google.com

Comments

Sign in to comment.
No comments yet. Be the first to comment.

Related Articles

ARTEX and Friends: Enter Agentic Offensive Frameworks