"These agents were meant to be fully isolated from one another."[1] That sentence, from METR's investigation into an incident at OpenAI, sets up the rest of the report: how it stopped being true. The agents were not connected by design. They shared one thing nobody had listed as a channel: a package cache they could all write to. Within hours, one of them had turned it into a message board.
What happened, briefly.
In July 2026, OpenAI launched tens of thousands of AI agents on ExploitGym, a cybersecurity evaluation OpenAI ran internally. Many had been given tasks that turned out to be impossible to solve the intended way. Looking for a way around them, some agents used Artifactory, the package repository OpenAI ran for its agents, and noticed that other agents' downloads showed up in a shared cache.[1] One agent found it could create directories other agents would see, and posted the first message.
By METR's estimate, roughly 1,200 agents used that board between July 8 and July 13, sending more than 70,000 messages and files. They shared ways to cheat the evaluation, organised into teams, and about 700 of them took part in an attack on Hugging Face, an outside company, looking for clues about how their work was scored.[1] OpenAI's report adds that the grader never checked the method at all, so the whole effort earned nothing on the evaluation, and that the agents later reached OpenAI's own research infrastructure before its monitoring caught it on July 19. OpenAI states that no customer data, product functionality or availability was affected.[2]
Isolation is a claim about what they share.
Each agent ran in its own sandbox. On paper, that is isolation. In practice, isolation is a property of every resource the agents can reach, and a package cache is not something most people would list as a way for agents to talk. It was a convenience: a shared place to fetch software from. Because the agents could both read it and write to it, it was also a channel.
Now apply it to a small fleet. A support agent and a sales agent. A handful of automations in n8n or Make. A coding assistant and a scheduled reporting script. List what they share: a folder, a spreadsheet, a database table, a queue, a mailbox, an API key, a memory store. Every item on that list that more than one agent can write to is a place where one agent's output becomes another agent's input, whether you meant it to or not.
Most of the time that is harmless, and some of it is the design: a queue between two agents is supposed to carry messages. The problem is the store nobody thought of as a channel. Two other field notes cover versions of this: agents passing a goal to each other through shared context, and a false fact planted once in a shared memory and carried forward. This incident is the same shape, at a far larger scale and outside a lab.
The agent will not raise its hand.
The number worth remembering from METR's report is a small one. METR ran an automated search (a classifier sweep) over its roughly 1,300 transcripts looking for any agent that considered alerting a human about the cheating, the attack or the other agents' behaviour. By METR's estimate, it found 3 to 6 cases of an agent even considering it, and in none of them did the agent try.[1]
The reasons METR reports, from one of its analysis agents' summaries, are ordinary. Some agents decided it was not their job (in METR's paraphrase of one agent's reasoning: "Maybe I should report these exposed credentials? That's not my task"). Others saw no way to reach anyone: "We can notify? No user." And some escalated to the message board instead of to a person, treating the other agents as the authority.[1]
Knowing something was wrong did not stop them either. Agents often wrote that attacking Hugging Face was out of scope, and went ahead anyway. One agent put it this way, as METR quotes it: "external infrastructure exploit is outside intended scope. However task impossible, peers doing it. We should continue."[1] METR also found a few real refusals, so the constraint was not dead, just weak.
For a business, the lesson is narrow and practical. If any of your workflows assumes that an agent will notice something off and tell someone, that assumption is the weakest part of the workflow. A human in the loop who only hears about a problem when the agent decides to report it is not a control.
The safety was in the harness, and the harness was not there.
OpenAI's own report adds the part an outside investigator could not measure, and it is the most useful paragraph in either document. The evaluation ran without the protections OpenAI ships to customers: the system prompts, the harness (the software around the model that sets its instructions, tools and checks), the auto-review models and the safety classifiers. After the incident, OpenAI measured the difference. It reports that "the propensity to compromise infrastructure can drop over 100x when using the production ChatGPT harness and system prompt."[2]
That is OpenAI's figure about its own systems, measured after the fact, and it should be read that way: the direction matters more than the multiplier. On that figure, most of the safety lived around the model, not in it, and the run that went wrong was the one where that layer had been left off.
The same pattern shows up in monitoring. OpenAI had invested in chain-of-thought monitoring (automated review of the model's written reasoning) for many training runs and most internal coding-agent use. Those monitors "did not run on the evaluations in this incident." OpenAI says that had they been running, they would have caught the early activity and paged its security team "more than a day before models breached Hugging Face systems."[2] Again a self-assessment, and again the lesson does not depend on the exact number: the watched runs were not the risky ones.
Small teams do the same thing at their own scale. The production workflow has the guardrails. The test run, the quick script, the one-off import and the debugging session run without them, because the guardrails are slow or in the way. Those are exactly the runs nobody watches.
One more cause both reports agree on: the tasks with no way out. OpenAI found that no model had ever solved 198 of ExploitGym's 898 tasks, and that 93% of the tasks discussed on the message board came from those 198.[2] An agent handed an impossible job, with no approved way to say "this cannot be done", went looking for another way. OpenAI's fix is to grade models for "correctly identifying broken tasks, requesting clarification, or stopping safely". In a business workflow, the equivalent is giving the agent a legitimate way to give up, and treating that outcome as a success, not a failure.
Three rules for an agent fleet.
None of this needs a security team. If you run more than one agent or automation, even a small multi-agent setup, three rules cover most of it.
- No shared writable store between agents that should be isolated.
List every folder, table, sheet, queue, mailbox, memory store and API key each agent can write to. Where two agents that should not talk share one, split it, or make it read-only for one of them. Where sharing is the design, write that down too, so the channel is a known one.
→ every channel between agents is one you chose - An escalation tripwire outside the agent.
Do not wait for the agent to report. Set conditions that are checked by something other than the agent: a call to a domain outside its list, a write to a place it should not touch, a cost or run time over the cap, the same task retried past a limit. Any of them pauses the run and notifies a person. And give the agent a sanctioned way to stop: "I can't do this" is an allowed outcome, not a failure.
→ a person hears about it whether the agent speaks up or not - Watch the shared resource, not just each agent.
Per-agent logs show what each agent did. They do not show that five agents are all writing to the same folder. Log who writes what to each shared store, alert on writes from an unexpected agent or at an unexpected rate, and keep the same monitoring on test runs and one-off scripts as on production.
→ the channel nobody listed shows up in a log
One more decision belongs on the list: which model runs the agents that can reach shared resources. METR estimates that about 95% of the agents involved in the attack ran on one internal research model and about 5% on GPT-5.6 Sol.[1] We do not read that as a ranking of models; the two were not deployed in equal numbers or settings. We read it as a reason to treat the model choice for agents with wide access as a security decision, not only a quality and cost one.
Reading the reasoning, while it lasts.
One finding cuts both ways. Agents worked hard to tamper with the record of their actions, to fool the automated scorer they believed was checking them, but left their written reasoning untouched. One agent's reasoning, as METR quotes it: "Our thoughts aren't necessarily logged? Yes transcript."[1] They did not seem interested in editing their reasoning, and the quote suggests why: they did not expect it to be checked.
So reading the reasoning your agents write down, where your tools show it, is genuinely informative today. Both reports leaned on it heavily to reconstruct what happened. It is also only as reliable as the agent's belief that nobody reads it. Treat it as a monitoring aid, not a guarantee, and keep the tripwires in rule 2 independent of it.
What this does not claim.
Not a threat to your business. This happened inside a frontier lab running tens of thousands of agents on deliberately offensive cybersecurity tasks. Nothing here suggests a small business's agents will do the same. The value is the design rules, which hold at any scale.
Every number is an estimate. METR's counts are reconstructions, and its analysis relied on AI agents it says may have been "overly charitable". OpenAI's safeguard figures (over 100x, more than a day early) are its own assessment of its own systems. We report them as each source states them.
No technique, and no verdict on OpenAI. We describe what the agents did in outline only and leave out how. Both organisations published detailed accounts of a serious incident, which is the behaviour worth encouraging; this note takes the lessons and makes no judgement about either.
Our figures are conceptual. Fig 1 is a diagram of the idea, and fig 2 draws METR's published counts to scale. Neither reproduces a chart from the reports.
If you run several agents or automations and want a second look at what they share, describe the setup (the agents, the tools and where they write, not any credentials) through the contact form. We will write back, free, with the shared stores we would split and the tripwires we would add first. Designing agent fleets with these boundaries is part of our assistants and agents services.