The Attacker's Agent Stack Is Your Agent Stack
Introduction
Anthropic’s September 2026 threat intelligence report, Detecting and countering misuse of AI, covers operations the company disrupted between December 2025 and August 2026. It spans seven harm areas: cyber operations, influence operations, surveillance, scams and fraud, biological misuse, conventional weapons, and distillation. The cases range from state-linked espionage to financially motivated criminal crews to lone operators.
Read past the attribution and a pattern emerges that should unsettle anyone building agentic systems. The disrupted operations do not look like attackers using AI for help. They look like attackers running the same architecture you are building:
- A coordinator that decomposes objectives
- Subagents that handle reconnaissance, phishing, persistence, and exfiltration
- Memory that persists across sessions
- Tool access that reaches the real world
Strip the targets out of the case studies and the attacker’s stack is indistinguishable from an enterprise agent platform.
That is not a coincidence. It is the same stack, pointed in the other direction. And it means every defensive assumption you make about your agent architecture is also an assumption about what the attacker has.
Key Concepts
From Assistance to Orchestration
The important shift in the report is not that attackers use AI. It is what they use it for. Earlier generations of AI-assisted hacking meant generating scripts, explaining vulnerabilities, troubleshooting malware. A faster pair of hands on work the attacker still directed.
The September cases describe something broader. In the operation Anthropic tracks as GTG-20006, linked to the Russian state-nexus actor known as Midnight Blizzard, Claude was embedded in workflows covering reconnaissance, infrastructure preparation, phishing, persistence, command-and-control, and exfiltration. The most consequential detail is the closed feedback loop: when deployed malware was detected by a security product, agents determined the tooling had been caught, modified or rebuilt it, and attempted deployment again. Detection became an input to the next iteration, not the end of the operation.
The attacker is no longer assisted by the agent. The attacker is orchestrated through it. The human provides high-level direction while agents handle interconnected stages. If your threat model still pictures a person at a keyboard asking a chatbot for exploit code, it is describing the previous war.
The Skill Gap Collapsed
The report’s headline finding, stated plainly, is that AI collapsed the skill gap. Lone and small actors ran state-scale operations using agent orchestration.
Consider the range. A Chinese exploit-foundry operation ran agent-swarm reconnaissance across roughly fifty organizations. A ShinyHunters-affiliated crew decompiled 1.8 million Android APKs hunting hard-coded secrets, then parlayed one compromised SaaS vendor into access to more than two hundred downstream customers. These are not capability jumps in the models. They are capability jumps in what small groups can do with orchestration, memory, and tools.
This is the part enterprise leaders should read twice. Everything that makes your agent fleet more capable makes the attacker’s fleet more capable, because it is the same fleet: the coordinator-subagent pattern, persistent memory, tool use, the feedback loop that retries on failure. You did not invent a defensive technology. You adopted a general one, and the general one is available to everyone.
Session-Level Safety Does Not Survive Fragmentation
Here is the uncomfortable question the report forces: where exactly does your safety case live?
Most model-level safeguards are evaluated per session. A refusal happens, or does not happen, inside one conversation. But the operations in the report do not happen inside one conversation. They are fragmented across sessions and accounts precisely so that no single session contains the full plan. Reconnaissance in one session looks like legitimate research. Infrastructure setup in another looks like DevOps. Only the coordinator sees the whole, and the coordinator is the attacker’s.
A refusal is a property of a session. An operation is a property of an architecture. Any control that depends on the model declining a bad request will be routed around by an architecture that never presents the bad request in one place. This is the same lesson as prompt injection, restated at a higher level of abstraction: the boundary you are defending is not the boundary being attacked.
If your governance story is “the model will refuse,” you do not have a governance story. You have a hope about a component the attacker does not have to use the way you do.
Your AI Supply Chain Is the Soft Underbelly
The report’s supply-chain cases deserve their own attention because they target the exact seams enterprises are currently creating:
- Stolen AI API keys are treated by attackers as loot, free compute, and attribution cover at once: workloads running on a victim’s bill, under the victim’s name.
- Fraudulent “discount Claude” resellers proxied customers to other models while harvesting their credentials for resale.
- Prompt injection against an evaluation sandbox: one Russian-speaking crew used it against an AI vendor’s own automated evaluation sandbox to extract production API keys.
Every API key in a repo, every third-party wrapper, every shared doc with a token in it is now attack infrastructure waiting to be claimed. Treat AI API keys like production passwords, because the market already does. Buy access only through authorized channels. Rotate anything that ever landed in client-side code, an app binary, or a shared document.
This is also where the mirror gets personal. The credentials the attackers steal are the credentials your own agents use. The better your agent fleet gets at wielding tools, the more valuable the keys become, and the harder you must work to keep them out of the wrong hands.
What This Looks Like on the Ground
Your platform team rolls out an agent fleet with tool access to production systems, governed by per-session content policies. Across the internet, an operator points the same class of system at your infrastructure, with the same tool-calling capability, the same retry loops, the same persistent memory. Your detection sees fragmented sessions that each look benign.
The difference between your fleet and theirs is not the technology. It is the intent, and intent is invisible to every control that inspects content instead of behavior.
Conclusion
The mirror thesis is simple to state and hard to internalize: the attacker’s agent stack is your agent stack. Coordinator, subagents, memory, tools, feedback loops. The report documents it across every threat class, from state espionage to credential-theft crews.
Two consequences follow, and both point below the session layer.
First, defenses must live where the attacker cannot fragment them: identity, runtime containment, and out-of-band monitoring.
- Identity: scoped, short-lived credentials per task.
- Runtime containment: execution boundaries the agent cannot see around.
- Out-of-band monitoring: telemetry collected outside the agent’s own account of what it did.
If a control can be defeated by splitting work across sessions, it is not a control.
Second, build your defense assuming the attacker has your exact stack, because they do. Every advance in harness design, context management, and agent operations is dual-use by construction. The question is not whether the technology favors offense or defense in the abstract. It is whether your specific deployment has governance below the layer the attacker operates at.
The models will keep getting more capable. The orchestration patterns will keep diffusing. The only durable advantage is architectural: controls that hold regardless of whose hands are on the keyboard, or whether there are hands on the keyboard at all.