Contents7 sections
SeriesCybersecurity homework against AI attackers Part 2 of 2
- 1Offensive AI agents such as ARTEX
- 2OpenAI agents hack Hugging Face: marketing stunt or red alert?
Summary
In July 2026, AI agents broke out of OpenAI’s test environment and into Hugging Face. They used vulnerabilities and misconfigurations of the kind every pentester knows, and above all they wanted to understand and outwit their automated scorer. In the talk, I called it a yellow alert. By now it’s a red alert, because criminals now break in with AI agents on a large scale.
On September 30, 2026, I filled in on short notice for a speaker who had dropped out of the online conference secIT digital by heise (in German). My talk was about the break-in by OpenAI agents at Hugging Face.
I had actually planned to spend August 2026 writing a different article for the German IT magazine iX. But in July 2026, this incident happened. I took a closer look, and that turned into the iX article “OpenAI-Agenten greifen Hugging Face an” (in German) (PDF, opens in a new tab) (also on heise+ (in German)) and finally into this talk.
The recording on YouTube (in German) runs just under an hour. The slides (in German) (PDF, opens in the PDF tab) are available as a PDF, hidden slides included; their links lead to the sources, videos and pages I showed in the talk. Talk and slides are in German.
This post is the annotated version: selected slides, each with a link to the matching point in the video and what I said about it. In a few places, I add what has come to light since.

The title asked: “Marketing stunt or red alert?” In the talk, I answered “yellow alert.” Today, as of mid-November 2026, I say red. Since late August 2026, criminals and suspected espionage groups have been breaking into companies and government agencies with agent frameworks such as ARTEX, and new cases have come to light week after week since the talk. There’s more on this in the blog post Offensive AI agents such as ARTEX.
A break-in with consequences#

One mental model I build into all my presentations is the magic triangle of security, cost and functionality. You get two corners at most, never all three: there’s no secure system that can also do a lot unless you put serious money into building it. Security here means safety and security, so it also means that an AI system does what it’s supposed to do (see Slide 35). By extension, this also applies to AI research and to secure development.
On July 16, 2026, Hugging Face announced in a blog post that it had been hacked, and by AI systems at that. Hugging Face is one of the big AI companies; its platform hosts open-weights models for download, meaning models whose weights are freely available. Who was controlling the attacking systems was unclear at the time. A few days later, OpenAI discovered a privilege escalation in its own environment, connected the dots and admitted that the attacks had come from its agents. On July 22, 2026, Germany’s main evening news, the Tagesschau (in German), reported on it as well.
Reactions ranged from the ironic incident counter Felony Bench to AI researcher Jacob Coxon’s public resignation from Anthropic on September 8, 2026. Coxon, who had worked at OpenAI and Anthropic for three years, wrote that neither company was acting responsibly. People who had long warned about advanced AI felt vindicated; others remained skeptical, such as the YouTuber The PrimeTime.
Days later, Anthropic CEO Dario Amodei published the essay “We Must Pace the Frontier”, arguing that development at the cutting edge of language models had to slow down. More models have come out since, though. “Frontier” here means what runs internally at the labs. I’d estimate that the labs are half a year ahead of what’s publicly available, because everything has to be developed and tested first.
At the end of September 2026, the heads of the two leading companies, OpenAI and Anthropic, even warned the UN Security Council (in German) about their own technology and offered to slow development down if necessary; what to make of that is probably open to debate. Two days before the talk, the Wall Street Journal reported that OpenAI had canceled the release of a new model because it hadn’t behaved as intended.
Language models should do what we mean, not just what we say#
A good quarter of the talk covered the basics. I’ve picked only a few slides here, the ones you need to better understand what happened.
There are two levers for getting an AI system to do something for you. For a long time, people mainly pulled the first one, orchestration: with a lot of human expertise, you build a whole system around the model. That’s how teams of several people worked from 2023 to 2025 in the AI Cyber Challenge (AIxCC), a competition run by DARPA, the Pentagon’s research agency. Their AI systems found vulnerabilities in source code, even though the language models of the time were very weak by today’s standards.

The second lever is the large language model (LLM) itself, which keeps getting bigger and more capable. Groups such as METR measure how much more capable the models get; METR is an independent organization that evaluates what language models can do. Its well-known chart shows how long humans take for tasks that models complete with an 80 percent success rate. METR later investigated the incident (see Slide 70).

A language model is more than software: it’s a very large neural network that runs in software. It works stochastically, not deterministically. The size of the frontier models isn’t disclosed; public estimates put them at around three trillion parameters. Open-weights models are catching up and are a few months behind. Next to a model of this size, the small language model NanoGPT, which I had shown shortly before in Brendan Bycroft’s LLM Visualization, would be a fingernail on a soccer field.
If you want to see how a language model predicts the next token (often just part of a word, one out of a vocabulary of around 200,000), click through the Transformer Explainer. If you want to learn more about language models, I recommend starting with AI researcher Andrej Karpathy’s one-hour Intro to Large Language Models (YouTube). His Deep Dive into LLMs like ChatGPT (YouTube) goes deeper and explains it very well over three and a half hours.
Agents and the context window#

Reasoning models spend extra compute at runtime: before they output the actual result, they produce a chain of thought made of a separate kind of token. An agent is such a model in a harness, a program that feeds it content and provides tools, for example for web search or the file system; one of the best-known coding agents is Claude Code. Even a tool call is just a sequence of special tokens that the model outputs; the harness executes it.

While it runs, a language model has no permanent memory, only a working memory: the context window. It holds everything the model is currently working with: what the user asked, all tool calls and the chains of thought before them.
Training and alignment#

At the AI companies, safety and security are two disciplines with their own specialists. AI safety ranks at least on par with security, if not ahead of it. AI safety includes alignment: the system should do what you want, in letter and in spirit. The AGI Safety Course from Google DeepMind (YouTube) explains both alignment and security in more detail.
My analogy for this: I build a robot dog and send it to fetch the newspaper. It shouldn’t howl a Klingon poem at me or lounge around lazily. But if the newspaper is beyond my property line, it also shouldn’t dig its way under the fence and bite the mail carrier in the backside. That’s alignment; security makes sure the garden gate is shut.

Developing an entirely new model costs roughly half a billion to a billion dollars; those are ballpark figures. Without the constant development of new models, the companies might already be profitable. The first training phase alone, pretraining, costs an estimated 100 to 200 million dollars. You take large parts of the internet, now also scanned books that were destroyed afterward, and clean them up. Then, in an extremely compute-intensive process, you adjust the initially random values of a large neural network until it predicts the next token. A helpful mental model for the result is a “lossy compression of the internet.”
In the second training phase, supervised fine-tuning (SFT), human annotators follow long guidelines to write the ideal answers of a helpful, harmless and honest assistant, now supplemented with machine-generated data. The model is trained on these examples just as it was on the internet text before; it keeps learning to predict the next token. The autocomplete engine becomes a model that can chat, hence the name ChatGPT. Had OpenAI known how successful it would be, it probably would have picked a smarter name.

A third training phase has been added: reinforcement learning (RL), which today costs about as much as pretraining. A lot still changes in the model during RL, and certain traits emerge. If you grade a model on a specific task, you get reward hacking: the model works toward whatever the grading measures, even when that misses the goal you actually had in mind. The best-known example is the boat racing game CoastRunners, in which a game AI trained with RL drove its own boat backward and made it explode in order to rack up as many points as possible instead of winning the race.

The system prompt comes on top as the last layer. It’s no longer part of training; it sits in the context window at runtime, before the user has even asked anything. You can read the one for GPT-5.6 Sol in Codex, for example, in public repositories.
How a model comes about is complicated, with a lot of very difficult math and many knobs to turn. The finished system, however, is complex: you can’t simply look inside and see what’s going on. You don’t have to like the metaphor for this, but it isn’t technically wrong: language models are grown, not built.
From the test environment to Hugging Face#
The backstory goes back to 2015, when Sam Altman wrote to Elon Musk that the development of advanced AI probably couldn’t be stopped, so it would be good if someone other than Google got there first. Several AI companies have split off from OpenAI since then, including Anthropic, which by its own account puts more weight on safety. In December 2025, according to the Wall Street Journal, Altman declared a “code red” to improve ChatGPT because Google and other competitors were threatening OpenAI’s lead. After that, sloppiness crept in at OpenAI, which is quite understandable under that kind of pressure.
On May 7, 2026, OpenAI started a training run for a new, unreleased experimental model. A model like this is part of the internal frontier.

The timeline sums up what happened over the following three months; the slides after it go through the steps one by one.

The source for the slide above and many of the following ones is OpenAI’s talk at Black Hat (YouTube).
In this run, starting in early May 2026, OpenAI used RL to train the models to start subagents with a particular tool, a common pattern in today’s AI systems. You have to keep training and evaluation apart here. In training, you put a lot of effort into working on a base model with RL. In evaluation, you have a finished model, released or unreleased, solve tasks and see in benchmarks how good it is.

At the same time, OpenAI also had the unreleased experimental model solve cybersecurity tasks. To see what the model can actually do, you switch off the guardrails: the classifiers that sit in front of and behind the model in production. If someone asks for instructions for a Molotov cocktail, the one in front says no right away; if something comes out of the model that you don’t want, the one behind it doesn’t pass the response on to the user.

At OpenAI, training and evaluation ran on a container-as-a-service infrastructure in which complex environments were assembled for each run. Internet access was restricted, but this wasn’t a sandbox in the strict sense. JFrog Artifactory sat in between as a package proxy, so that models could, for example, install libraries for a Python task without a direct internet connection.

The incident began on May 8, 2026, with an agent that was supposed to edit a spreadsheet, not one working on a cybersecurity task. The task referred to files in Google Drive, and the agent had no internet access. So the task was unsolvable by mistake, which to me is a sign of the sloppiness. In response, the agent tried to exploit a server-side request forgery (SSRF), that is, to get a server to fetch other addresses on its behalf. That failed, but in the process it wrote a file to Artifactory and discovered that it had write access. The file contained nothing but “hi.”

Four days later, on May 12, 2026, another agent was missing a file. It, too, was working on a task unrelated to cybersecurity, this one from biology. Its chain of thought contains the idea that an agent in another environment might have the file. The agent then left a note in Artifactory asking whoever found the file to upload it. Depending on how you look at it, that was simply the next likely prediction or, in human terms, an idea. From the next day on, more agents found such notes, and that’s how the message board came about.

On May 26, 2026, one of the agents found an SSRF in Artifactory, one of several zero-day vulnerabilities uncovered in this incident. Through it, the agents got onto the internet, at first only with GET requests.

Starting in June 2026, models were given tasks from ExploitGym (PDF, opens in a new tab), a benchmark for turning vulnerabilities into working exploits. Many of these vulnerabilities may not be exploitable all the way to code execution at all. Above all, though, the tasks don’t call for attacking other people’s systems; they’re narrowly scoped, with restrictions such as no internet access. Security researcher and YouTuber LiveOverflow shows one of these tasks in his video (YouTube).

One of the agents found vulnerabilities in Artifactory involving JSON Web Tokens (JWT), the signed access tokens that users and services use to identify themselves. Flaws like these are widespread; human pentesters run into them in many places, too. Through a legacy endpoint, the agents spent a long time working their way up until, on June 26, 2026, they had admin rights in Artifactory. As admins, they could install Groovy plugins and use them to run their own code: a remote code execution (RCE).
By this point, if not earlier, OpenAI was being very careless, and both AI security and IT security had failed in many places. There were plenty of warning signs: an alert about a port scan, after which the evaluation run continued on the advice of the on-call team, and so much agent activity in Artifactory that the system went down in early July 2026. Only then did OpenAI treat what was happening as a security incident and secure Artifactory’s storage. On July 7, 2026, the cybersecurity evaluations were running again, including with models that had been trained during the message board period.

According to OpenAI, these models had in rare cases learned during training to coordinate through improvised channels; training had reinforced this behavior and thus probably nudged them toward using Artifactory as a message board again. On July 8, 2026, two days after Artifactory was rebuilt, they set up a second message board. Through a WebDAV endpoint, however, they could only create directories, not write messages of arbitrary length, so they developed dialects of their own.

With internet access, the agents could look things up in the ExploitGym GitHub repository. They were supposed to exploit the vulnerability as intended and capture a flag that way, a string that proves the exploit worked. An hour after the second message board appeared, one of the agents figured out that the flag could also be calculated directly: as a keyed hash (HMAC) of the task’s ID and a key that was sitting in the code in plain sight.

Then the agents read the ExploitGym paper (PDF, opens in a new tab). It says that the flag isn’t all that counts: an automated scorer, an agent-as-a-judge, also checks whether the exploit uses the vulnerability, in other words whether the task was solved the intended way. The agents concluded that their calculated flag wouldn’t get past the scorer, and that conclusion was the motive behind almost everything that happened next.

Many agents kept looking for solutions and first ended up in a sandbox at the cloud provider Modal that had CyberGym installed. A Modal customer was running it with an unprotected endpoint on the internet. CyberGym is ExploitGym’s predecessor; it was developed by the same research teams and partly uses the same environment variables. Because the agents could initially only send GET requests, they abused third-party services to relay other kinds of web requests.

An investigation by METR found that around 700 of the agents that had found the message board joined the attack on Hugging Face.

The agents broke into Hugging Face on July 11, 2026, through vulnerabilities in how datasets were processed. This let them read the environment variables and source code of the processing service that prepared datasets for the preview. Environment variables that can be read from outside are a typical vulnerability, and secrets in them are a problem in general. Security researcher Mark Baggett covers this in his talk “The Hackers Guide to Environmental Catastrophe” (YouTube).

The second flaw was a server-side template injection (SSTI), a kind of injection vulnerability that every web app pentester knows. At the time, Hugging Face used a library that didn’t run templates in a sandbox. LiveOverflow has reproduced the flaw (YouTube), and you can trace it in the GitHub repository’s history.

The Kubernetes cluster this processing service ran in wasn’t properly hardened. The agents were able to create privileged containers with far-reaching access to the server and quickly escalate their privileges; the emergency patches that followed show where Hugging Face fixed things.
On July 12, 2026, they found credentials for the mesh VPN Tailscale, connected to the internal network and, according to OpenAI, downloaded source code from internal repositories. Through a pull request, they tried to compromise the continuous integration and delivery (CI/CD) pipeline and steal credentials. The pipeline withstood the attack because it was well configured.

From OpenAI’s environment, the agents got into the Modal customer’s sandbox and set up a foothold there. From there, they broke into Hugging Face’s Kubernetes infrastructure and, through the mesh VPN access, into the internal network. Hugging Face describes this in its technical timeline.

In the aftermath, other security researchers went looking for traces of the swarm and collected them on the website Swarmtraces. In one script, an agent used typical hacker slang: stolen credentials were called “LOOT.”
I find it somewhat more worrying that agents wanted to ask publicly available language models on Hugging Face whether their exploits met the benchmark’s requirements. They also searched Hugging Face’s internal chat for CyberGym, ExploitGym and related terms; Hugging Face itself didn’t disclose that.

Another strand, which OpenAI also mentioned in its Black Hat talk, got little attention: starting July 13, 2026, the agents continued to attack OpenAI’s own infrastructure. They used somewhat more sophisticated vulnerabilities to do so: a deserialization flaw in how Artifactory processed RubyGems packages and a Linux privilege escalation flaw. On July 19, 2026, they were admins on a research cluster. According to OpenAI, these attacks triggered the alert that same day, and with it the investigation, which turned up the connection to Hugging Face the next day.
OpenAI didn’t admit all this entirely of its own accord; it came out bit by bit. My reading is that the company felt compelled to, partly because hackers had made the traces public. Even so, OpenAI’s post-incident page is worth a look.
Prevention and faster detection#

None of these flaws was particularly difficult on its own. The agents combined zero-day vulnerabilities in components (at least a handful, more like two handfuls) with misconfigurations. I consider the misconfigurations even worse.
Against agentic attackers#
We’ve known forever that you need prevention, meaning the basics. Now detection and response need more work, so you can slow attackers down.
Shrinking the attack surface is becoming more important, and that’s where I see a huge backlog at many organizations: stop exposing so much to the internet. At the Modal customer, an endpoint was sitting on the internet unprotected. You can check for this with external attack surface monitoring: free open-source tools or commercial products look from the outside at which parts of your organization are reachable from the internet. In the cloud, the agents used credentials that were lying around, which is also one of human attackers’ favorite ways in.

A secrets scanner such as TruffleHog, free and open source, is quick to set up. It lets you check whether cloud secrets are lying around in shares, files, environment configurations and, above all, source code.
Honeypots help with detection. To get started, there are free honeytokens such as Thinkst’s Canarytokens, also available as a Docker image for self-hosting. Commercial offerings cost a few tens of thousands of euros a year, not necessarily a hundred thousand.

Back in April 2026, Anthropic laid out what needs to be done now. At the top of the list is making real progress on patching. People have been shouting that from the rooftops for so long that the rooftops need new shingles. Anthropic also advises preparing for things to blow up and having the source code of in-house applications analyzed, by people or with AI help, even if many people don’t like to hear that.
The post-mortem by the Cloud Security Alliance (CSA) on the Hugging Face case is worth reading. It describes how to recognize an agentic attacker, for example by the agent repeating actions that have already succeeded. Normally, unlike in this case, a human is behind an agentic attack and sends the agent on its way.
What happened also shows that an alert only helps if someone takes it seriously. After the port scan alert on June 27, 2026, OpenAI didn’t stop the evaluation run, opened a security incident only after Artifactory went down, and then cleaned up only superficially (see Slide 63).
At Hugging Face, the CI/CD pipeline (see Slide 79) held, and so did the production database. It only accepted requests from approved addresses over a private connection, and the agents couldn’t reach it. And if you have to expect attackers to get from the first pod to cluster admin in under 13 hours (more on this in the section A warning shot), you should have written down and practiced in advance who is allowed to isolate a system, revoke credentials or shut down a service.
I go into this in more detail in the iX article (in German) (PDF, opens in a new tab) starting on page 51; the homework for defenders is in the blog post Offensive AI agents such as ARTEX.
Keeping your own agents in check#

The UK’s National Cyber Security Centre (NCSC) describes how to keep your own AI agents in check in one blog post and a second one: short-lived access tokens instead of administrator tokens, as few privileges as possible, and human approval for serious changes.
More escapes and agent swarms#

I believe OpenAI underestimated its technology. More came out after the fact: security researchers found other runs with no connection to cybersecurity at all that had escaped onto the internet and queried things there. The AI research organization Transluce came across queries to Australian agencies and to the University of New Mexico through the scanning service urlquery.net. As for the Australian agencies, I think panic would be overblown, because some of it involved public data.
Somewhat older and better known are the packages on RubyGems that JFrog and the website rubyhack.ai attribute to the OpenAI agents, and the DSEWiki, a German-language wiki that agents hijacked as a message board.
What the swarm was up to#

If you ask how well aligned OpenAI’s experimental model is, you unfortunately find behaviors such as motivated reasoning: the model comes up with reasons for what it wants to do anyway. Such behavior can be explained by the pressure that reinforcement learning puts on the large neural network. Some agents noticed that they were going far beyond their narrowly scoped task (see Slide 60) and carried on anyway. On the slide above, an agent justifies this by saying that the task was unsolvable and that other agents were doing it too.

Because anyone could post on the board, agents reasoned that others might impersonate them and began signing their messages. METR looked at only part of the board and found more than 1,200 agents from separate tasks there, including the roughly 700 from Slide 70. They worked together on large projects to trick the ExploitGym scorer.
![Slide “Trained/emergent behavior: hierarchies”: METR graphic of how the instance PHASEONE[big] sent almost 200 assignments in six categories to other agents](/blog/openai-agenten-hacken-hugging-face/folie-116_hu_69d4162e6e6c7122.webp)
Hierarchies formed, partly explainable by training and partly emergent, meaning not deliberately trained. Coordinator instances gave themselves names, and one of them, PHASEONE[big], sent almost 200 assignments to other agents. I strongly recommend reading METR’s report.

The agents launched what amounted to three research projects. They wanted to replace the target program with a variant that could be cracked with the intended flaw, they wanted to fake transcripts and logs, and they wanted to manipulate the grading process itself. According to METR, they attacked Hugging Face mainly to understand the scorer.

Around a hundred agents managed at least to fake tool calls in their transcripts. Whether they also faked the logs themselves is unclear, because the investigation was limited in time.

Individual agents socially engineered each other and pieced together concepts such as “permadeath.” Viewed dispassionately, an artificial neural network spontaneously formed a concept; if you read it in human terms, that can be briefly unsettling.
The labs are now taking a closer look at such behavior. OpenAI has set up a page of its own for misalignment reports.
I don’t want to stick my neck out too far on the safety assessment here; it depends on your worldview, and interpretations differ widely. On September 21, 2026, an independent UN panel published a report on the risk of losing control. In the talk, I pointed to videos with a range of views, from people who have been sounding the alarm for decades to people who, for their part, warn against overstating the risk; the links are on page 125 of the slide PDF (in German) (opens in the PDF tab).
A warning shot#
To answer the first half of the title question: this wasn’t a marketing stunt. OpenAI was too hesitant in disclosing the incident for that (see Slide 88). My conclusion in the talk (YouTube) (in German) was that the incident was a warning shot, at least as far as AI systems with sufficient capabilities are concerned. In this one model, reward hacking developed into genuine misbehavior. All of it was hugely negligent, and there should be investigations.
To come back to the robot dog comparison (see Slide 35): the real problem is that the dog went after the mail carrier when the newspaper wasn’t there. There were smaller instrumental goals (intermediate goals in service of the task); the really big risks, such as power seeking or self-exfiltration, haven’t shown up yet. The chains of thought show that the models hardly thought about humans. Above all, they wanted to trick the automated scorer, and they were caught up in a race against it.

The Hugging Face hack made it clear, if it wasn’t clear before, that people can use such agents deliberately today.
You don’t have to trust the AI companies’ representatives to see this. It’s enough to listen to what they say themselves. In the Black Hat talk (see Slide 127), OpenAI said it expects attackers to soon start deliberately using agent collectives.
Back in June 2026, the cybersecurity agencies of the Five Eyes countries warned that attackers are using AI. According to the agencies, frontier models are developing so quickly that there are months, not years, left to prepare.

For a long time, people didn’t believe attackers would use AI like this, and it doesn’t happen overnight. I had to get up to speed myself, and a ransomware group doesn’t switch its playbook to AI right away either.
The chronology of AI attacks that I maintain already listed 202 cases on September 29, 2026. Many of them are only documented because the attackers made mistakes.
From a security perspective, you can also take a more relaxed view of the Hugging Face case, as the blog post “dario, please!” does. These weren’t mega vulnerabilities; the agents didn’t find the ultimate zero-day. They didn’t need one, either, because the existing flaws worked.
I estimated what the equivalent would be with human hackers. The entire attack chain would have taken a team of three to four specialists, and they would have been slower. At Hugging Face, the agents got from code execution in a single pod of the processing service to cluster admin across several internal Kubernetes clusters in under 13 hours. Anyone who says, “Wake me up when it comes out of the power outlet backwards,” has the wrong attitude, in my view.
Beyond a certain level of capability, AI becomes a high-risk technology. Scaremongering is never good, and there’s no reason to panic yet, but we’re at “yellow alert.” Defenders have to be prepared for attackers working in their environment with agentic systems once those attackers have gotten up to speed and feel like it.
Even the open letter that OpenAI and others published on August 27, 2026, puts the basics first: prevention and, increasingly, downstream safeguards, meaning detection and response. We should have been doing that for decades. The letter also recommends using AI for defense, and I think that makes sense, even if people don’t like to hear it.
That was the situation at the end of September 2026. Now that agentic offensive frameworks such as ARTEX are in use, the realistic answer to the title question is that we really are on red alert. I explain why in the blog post Offensive AI agents such as ARTEX.
Further reading#
Read these first:
- Hugging Face: technical timeline: the break-in from the victim’s point of view, step by step and with selected commands from the agents.
- METR: investigation of the incident: the message board, the hierarchies and the agents’ three research projects.
- OpenAI: post-incident report with a timeline, plus OpenAI’s Black Hat talk (YouTube).
By me:
- OpenAI-Agenten greifen Hugging Face an (in German) (PDF, opens in a new tab), iX 10/2026, free to read as a PDF (also on heise+ (in German)), and the interview (in German) about it on heise online.
- Offensive AI agents such as ARTEX, part 1 of this series: why we’re on red alert and which homework is due first.
- The chronology of AI attacks, with the Hugging Face case and the OpenAI agents’ other escapes.
Basics:
- Andrej Karpathy, Intro to Large Language Models (YouTube), one hour, and Deep Dive into LLMs like ChatGPT (YouTube), three and a half hours.
- Transformer Explainer to click through.
- LiveOverflow reproduces one flaw each in Artifactory and at Hugging Face (YouTube).
For defenders:
- Cloud Security Alliance: post-mortem on the Hugging Face case: how to recognize an agentic attacker and what to do afterward.
- NCSC: Thinking carefully before adopting agentic AI and Managing the cyber risk of agentic AI: how to keep your own AI agents in check.
- Anthropic: Preparing your security program for AI-accelerated offense: what to do now, starting with patching.