People keep asking whether we have detection rules for ARTEX and Cairn. The question sounds similar to asking for coverage of a new malware family, but these frameworks play a different role. They automate parts of the attacker’s work: investigating a target, choosing tools, interpreting results and deciding how to continue.
That changes how attacks unfold, how much time defenders have to react and how confidently we can connect observed behavior to a particular operator.
We have found a few implementation fingerprints and written rules for them. Those are useful, but they are a small part of the story. The much bigger change is that an increasing share of the decisions during an intrusion can be delegated to software.
What are ARTEX and Cairn?
ARTEX is an open-source autonomous penetration-testing system built around multiple LLM-driven agents. It separates planning from execution: a planner identifies promising avenues, worker agents investigate them with real tools, and their results feed back into the next round of planning.
A web interface lets the operator set objectives, review findings and provide guidance. The system also supports reusable skills and external tools. The Global Edition repository examined for this article is a fork of the original ARTEX project.
Cairn takes a more general-purpose approach. Its developers describe it as a state-space search engine: given a starting point and a goal, it explores possible paths between them, with penetration testing as one application.
Workers share a record of findings (“Facts”) and proposed next steps (“Intents”), while the operator can add guidance (“Hints”). Rather than following a fixed sequence, workers use this shared record to decide what to explore next and contribute their results for subsequent tasks.
The framework is not the payload
ARTEX and Cairn provide the structure for an AI-driven attack workflow. The operator supplies an objective, while the agent uses the available tools and information to work toward it. In this setup, the framework runs on the attacker’s side. What reaches the victim is the resulting activity: requests, commands, scripts, payloads and changes to the system.
The components driving that activity are interchangeable.
An operator can use a commercial model, a local open-weight model or a model they have modified themselves. They can change the prompts, supply custom skills, add knowledge and provide an entirely different collection of tools. The framework’s built-in instructions also influence the workflow, but they do not impose a fixed attack sequence or payload.
This means that two operators using ARTEX can produce very different intrusions, while operators using different frameworks can execute the same commands and deploy the same malware. A webshell does not become an ARTEX-specific artifact because an ARTEX agent chose to deploy it. The relevant implementation is still the webshell itself.
The attribution problem
This interchangeability is what concerns me most about behavioral attribution. Analysts use recurring tools, techniques and working habits to help connect intrusions. But a sequence of commands selected by an agent may tell us more about a shared skill, the available tools or the model’s preferred approach than about the person directing it. An operator can change those components without changing their objectives, and the next intrusion may look quite different.
Shared tooling has always complicated attribution. Agentic frameworks extend that problem to decisions that previously reflected more of the human operator’s experience and habits. Unrelated actors could end up following similar paths because their agents work from similar instructions.
Conversely, activity from the same actor could become harder to link after a configuration change. Infrastructure, targeting, custom tooling and operational mistakes still matter.
My expectation is that the behavior generated during an intrusion will become a less dependable actor fingerprint on its own.
The small implementation footprint we can detect
The framework and its bundled components can still leave a few recognizable traces.
Predefined HTTP tools may use characteristic client identifiers, and the framework’s own executable and configuration files contain implementation markers. Bundled skills can introduce additional patterns when their supplied scripts are used. These are concrete detection opportunities, even though they do not define the wider attack.
At Nextron, we have written the following rules. Some address HTTP traces in logs; others identify files belonging to the framework on a machine where it is present. Norma, which appears in several entries, is the underlying general-purpose agent engine. It is neither exclusive to ARTEX nor malicious on its own.
| Detection | What we look for | Where we look |
|---|---|---|
Potential ARTEX IOCs |
The default build filename of the framework executable. | The filesystem of a host holding the framework binary. |
ARTEX User Agent |
HTTP client identifiers from ARTEX’s enrichment and self-update components. | Proxy logs. |
Norma User Agent |
Norma’s HTTP client identifier. | Proxy logs. |
HKTL_ARTEX_Forensic_ |
Characteristic ARTEX component and platform-management text. | Saved logs and other scanned files. |
LOG_Norma_UA_Oct26 |
Norma’s HTTP client identifier in file content. | Saved logs and other scanned files. |
HKTL_ARTEX_Oct26 |
Internal ARTEX implementation markers. | Executable files. |
HKTL_ARTEX_Docker_Oct26 |
ARTEX deployment configuration markers. | Container configuration files. |
PUA_NORMA_Usage_Oct26 |
Embedded references to the Norma agent library. | Executable files. |
Noisy attacks can still succeed
Speed is the other important part of this development. An agent can begin with a familiar, generic technique and try alternatives when it encounters a problem. That may mean choosing another tool, adjusting a script or abandoning one route and investigating another.
The initial attempts can be quite recognizable. From a detection perspective, there may be nothing particularly subtle about them.
But recognizable activity does not guarantee timely intervention. While an analyst reviews an alert from the first failed attempt, the agent can already be working through alternatives. When one succeeds, it can continue with the next task without waiting for a human operator to return to the keyboard. Traditional automation already executes predefined steps quickly; these workflows automate more of the decisions between those steps.
An attack can therefore be loud, trigger valid detections and still make progress before the organization responds.
Why I expect the near future to get worse first
I expect AI to make software considerably more secure over time. Better code reviews, testing and assistance with fixing vulnerabilities should help remove many obvious mistakes. But that improvement has to reach the software organizations actually run. Defenders have an enormous backlog of existing code, applications and dependencies to examine, fix, validate and update. Some systems will remain in service long after better development methods become available.
Attackers can benefit from a more capable model or an improved tool collection much sooner. They can apply those capabilities to the existing software landscape without waiting for organizations to replace it. I also expect increasingly capable models on affordable hardware to make these workflows accessible to more operators.
That is why I see the near future as an extension of the current problem with potentially greater impact, rather than a period in which defensive AI has already solved it.
Even if common coding flaws eventually become harder to find, they are not the only route into an organization. Stolen or reused credentials, social engineering, exposed secrets, insecure configurations and compromised suppliers remain relevant. An agent does not need to develop a novel exploit to make progress through those weaknesses. More secure software would be a substantial improvement, but it would not remove the other ways organizations get compromised.
What this means for post-compromise detection
For our work, the useful question remains what the attack left behind. A campaign may reuse infrastructure, a particular loader, a webshell or a naming convention. Those details can support detection and investigation without being properties of ARTEX or Cairn. Generic detections for malicious scripts, credential-harvesting tools, persistence and other compromise artifacts remain relevant because the familiar techniques have not disappeared. There is simply another way of choosing and combining them.
This is the focus of compromise assessments with THOR: examining systems for backdoors, suspicious modifications and other evidence that access was obtained or may still exist. We do not need to identify the model or prompt before recognizing a malicious artifact. Faster attacks make that investigation more important, not less. The initial activity may be over, but what the attacker changed or installed can remain.
Sources
- ARTEX Global Edition: architecture and project documentation
- Cairn: project documentation
- ARTEX Global Edition: defense guide
- AhnLab: ARTEX analysis
- PLURA: ARTEX and LLM experiment
- Microsoft: ARTEX campaign analysis
- Gambit Security: autonomous agents attacking online retailers
- Huntress: AI, Scripts, Operator: Inside the ConnectWise Attack





Boris Deibel
Nextron Threat Research Team
Florian Roth
Stanislaw Mrozowski