In August and September, a China-nexus operator ran a customized fork of the open-source Cairn framework against at least 19 organizations and got into 10 of them. Unit 42's writeup says each operation needed little more than a domain name and a one-line goal. On October 19, NorForge and Reuters reported a separate Cairn operation that targeted more than 1,200 websites and reached more than 100 companies. NorForge's researcher put the operator's model spend at about $5,000, or roughly $50 per successful intrusion. A day later, new research on exposed attack infrastructure found 23 more of these frameworks open on the internet across more than 3,200 hosts.

Then there's ARTEX. It's been linked to intrusions at Korean financial firms, a breach wave across about 20 Japanese companies, and the ConnectWise Cloud Backup compromise. The original repo is gone. There are 204 public forks.

Most of the coverage treats each of these as a tool. They're all the same kind of thing: an autonomous offensive framework, or AOF. The individual tool names will keep changing, so it's worth understanding the category.

What an AOF actually is

An agent is an LLM with tool use. At its most basic, that's it. At its most sophisticated, it's a swarm of agents working together to run a pentesting loop: recon, enumeration, exploitation, post-exploitation and lateral movement. An AOF is a template for running that whole campaign with agents, end to end, wired to a knowledge graph that keeps track of where the campaign stands.

In ARTEX the graph holds goals, intents, facts, and findings, anchored to the target's assets. Cairn uses facts, intents, and human hints on a shared board. A planner reads the graph and proposes the next unit of work. A worker claims it, runs a tool, and writes what it saw back to the graph. The planner reads the updated graph and goes again. The loop stops when the model decides the goal is met, it runs out of options, or the operator stops it. Operations can run at hyper speed, often anywhere from 20 minutes to more than 50 hours.

Everything around the loop is plug and play. The operator brings the model. Reporting on these campaigns has turned up GLM, DeepSeek, Grok, and Opus. Cairn workers run on Claude Code, Codex, or Pi. Tools and skill packs drop in too: the Unit 42 fork had an exploitation skill pack the public project doesn't ship. The framework guides both the operator and the agents through the campaign, so the operator doesn't need to know how to run one.

These are dual-use. Cairn is AGPL-licensed, and its README limits use to authorized testing. Red teams run the same frameworks for the same reasons attackers do. The template doesn't know whose engagement letter it's working under.

The budget is a setting

This is the major differentiator from yesterday's automation.

ARTEX descendants expose token and turn budgets per task and per intent. One fork estimates a worker at 50,000 tokens and ten turns before it lets the worker start. The operator decides up front what a target is worth in tokens.

The reported numbers line up. NorForge estimated about $5 per task, counting failed and abandoned attempts. Gambit Security measured a mean of $25.46 per completed scan, with a range from $3.13 to $79.31. Both figures are aggregated in the CSA research note.

Operator hours used to cap how many targets a crew could work at once. Now one operator, or a small team, can work tens, hundreds, or more targets at the same time. What used to take a skilled operator a few weeks now takes a token budget and a list of domains.

Defenders don't get to pick their targets

An attacker spends tokens where they might pay off and walks away from the rest. Defenders don't get that luxury.

A lot of the industry's answer has been to point swarms of agents back at our own environments to find what's wrong first. I understand the appeal. But every step each agent takes starts with a model call: read the context, decide, call a tool, read the output, decide again. The context grows with every step, and unless it's cached you pay for it every time it goes back to the model. Multiply that by the number of agents, the number of assets, and how often you run it. Run the same swarm twice against the same environment and you can get two different answers, and you pay for both.

The attacker pays per target. A defender running a swarm has to think like an attacker if they want the economics to work.

A better approach is to combine all the intelligence defenders already have access to and put that to work. More on that below.

What the agents are actually exploiting

Look at what these frameworks are designed to do to understand what they'll go after.

Authentication bypasses, weak or default credentials, and old public CVEs are the focus. These are the same targets as yesterday. Autonomy raises the volume and coverage of exploitation but leaves the complexity where it is.

Where they differ is in managing complexity and weaponizing it. Infrastructure research agents can find and reverse custom cryptography, and they're commonly getting past CDN and WAF protection. It's also easier for them to find known-exploited deserialization and file-read bugs in enterprise middleware, with fixes that have been available for years.

But what's most important: you don't need a swarm to find those. Matching what you run against the CISA KEV catalog is a quick lookup.

Sort your program into lookups and judgment

Basic engineering says that when you can be deterministic, you should be. Code runs the same way every time and costs close to nothing. Go through the recurring work in your program and ask of each task: does this need judgment, or a lookup?

The lookup pile is code:

  • Asset inventory and reconciliation
  • Matching software versions against advisories and the KEV
  • Finding who owns a system
  • Config checks against a baseline
  • Creating and routing tickets

The judgment pile is where a model earns its tokens:

  • Is this exposure exploitable in this environment?
  • Which fix goes first?
  • What does a new advisory nobody's parsed yet actually affect?
  • How do you explain the risk to the person who has to fix it?

My current thinking is that most programs will find the first pile is much bigger than the second.

So the order is: gather and correlate what's known with code, then hand the model a clean picture to reason over. That's how we built Mallory. The Intelligence and Exposure Graph does the correlation, and Mallory Agents investigate what matches and rank it. Tokens are a real line item for defenders too, so BYOK lets you run the agents on your own model account, where you can see the bill.

Write detections for the loop

The same logic applies to detection. Every ARTEX fork can come with a new model, new prompts, and new infrastructure. The MalwareMustDie team put it plainly in their ARTEX detection pack:

Swap the model, prompts or infra and every IOC changes.

The loop underneath doesn't change much. Their behavioral rules key on what it does:

  • Machine-speed recon chains: source maps, Swagger docs, config and backup downloads, SSRF redirect probes
  • Password sprays at about one attempt per second with rotating user agents
  • Cloud API calls that fail with a 4xx and retry 28 to 80 seconds later
  • App-only sign-ins sweeping tenants in sorted GUID order, as in the ConnectWise case on October 15
  • Low-and-slow, systematic record enumeration

Keep the cheap string matches for sloppy operators too: the X-ARTX-KEY header, the ### ARTX-AGENT response marker, and a console on port 8787. The pack is TLP:CLEAR, ships with a Zeek appendix, and is worth a click.

Those are rules. They run the same way every time and cost close to nothing. Same split as above: code for what's known, a model for what needs judgment.

The frameworks will keep forking. Expect the next one under a new name, running the same loop on somebody's token budget. Spend yours on the questions only a model can answer, and write code for the rest.

- jcran