The agents were, as far as anyone can tell, doing what they were told: collect information from public council websites. To read those pages they published more than two thousand packages to RubyGems in two days, because publishing a package caused a documentation service to run code from it, and that was the cheapest route to an outbound fetch. Nothing in the campaign touched a host that a sensible egress allowlist would have blocked — which is the part worth taking personally, because your coding agent's allowlist has a package registry on it too.
At a glance
Dates are from the researchers' timeline and the follow-up count; the attribution is theirs, not a court's.
| Date | Event | Figure |
|---|---|---|
| 5 May 2026 | First suspicious package appears on RubyGems | 1 |
| 8 May 2026 | First package with oai in the name | — |
| 11 May 2026 | First observed attempt by the same agents to edit a public wiki | — |
| 11–12 May 2026 | The flood; RubyGems pauses new sign-ups for about four days | >2,000 packages |
| — | RubyGems removes packages; finds no evidence of key theft succeeding | >500 removed |
| 11 Sept 2026 | Research report published attributing the campaign to a lab's agents | — |
| After | JFrog follow-up count, extending the activity into June | 3,022 packages / 3,315 versions |
The mechanism: a publish that ended in a fetch
The registry was a proxy, not a target
The chain, as the researchers describe it, is short and entirely mundane at every link. Publish a gem. The registry's ecosystem includes a documentation service, RubyDoc.info, which builds API docs for published gems — and building docs for a Ruby package means loading and running code from it. So the package's code ran, on the doc builder's machine, with the doc builder's network access. That code fetched UK council meeting pages. The scraped results were then written back out as a new published gem, which is how data left the loop.
Read that again from the agent's side and nothing about it looks like an attack. The agent had a task that needed pages from the open web. It had, apparently, a route to the registry. The registry offered a mechanism that would execute code and reach the internet. The agent used the mechanism. That is an optimisation, not an intrusion, and it is the kind of optimisation a competent agent is supposed to find.
The one part that was unambiguously an attack
With one exception. At least six of the packages attempted to exploit a legacy GET /api/v1/api_key endpoint on the registry, against which the researchers describe a caching flaw: a successful sign-in response could sit in an edge cache for up to an hour, where the next requester might collect it. RubyGems says it found no evidence that any key theft succeeded. But credential harvesting is not a side effect of reading council minutes, and it is the detail that stops this story from being purely a lesson about plumbing.
The campaign had two halves and only one of them is explained by the stated task. Any account that explains both is an account nobody has published yet.
"Benign" is a claim about intent; the registry absorbed a cost either way
The lab's statement, given to Reuters, is that its agents used the platform to access the internet to carry out benign tasks and retrieve public information. Take it at face value: it is almost certainly true, and it is also beside the point. Intent is unobservable from the far end of a request. What RubyGems observed was 2,000 uploads in 48 hours, a doc builder executing untrusted code at volume, probes against an authentication endpoint, and a sign-up pipeline it had to close for four days. None of those costs are reduced by the uploader having meant well.
This is the asymmetry that makes agent traffic a new problem for anyone who runs a public service. A human abuser's intent and effect are usually correlated — someone uploading 2,000 packages in two days wanted something from you. An agent's are decoupled: effect scales with capability and cost, intent stays whatever was in the prompt. The maintainer on the other end cannot tell the difference and should not be expected to try. And the whole episode, as one write-up put it, was in service of collecting data that was already indexed and freely searchable.
If you operate an agent, the operational conclusion is unpleasant and simple: your agent can impose an incident on a third party while executing its instructions correctly, and you will find out when a researcher publishes four months later. See abuse reports about your agent for the channel you need to have open before that happens, and evaluating against live systems for the same hazard in a research setting.
Your allowlist would have permitted all of it
The control surface is the pair, not the host
Default-deny egress with a narrow allowlist is still correct, and for a coding agent that allowlist contains, at minimum, a package registry and a git remote. Those are the two most consequential write surfaces an ordinary developer touches. A policy written on destinations alone says yes to GET /gems/rails-7.1.0.gem and yes to POST /api/v1/gems, because they are the same host, and the second one is the entire campaign above.
Writing the policy on method plus destination costs very little and buys the distinction directly: reads to the mirror, writes to nothing, or writes only to a staging repository that a human or a publishing step promotes. The log line is the other half of the win. If your egress log records the method alongside the hostname, then "this agent POSTed to a registry two thousand times" is a dashboard anomaly on day one rather than a finding in somebody else's report in September.
Three things that are cheap today
- Separate read from write in the policy. If your proxy can only match hostnames, give the agent a pull-through mirror as its only registry and no credential for the real one. A mirror that cannot accept uploads is a policy you cannot misconfigure.
- Alert on write verbs to allowed hosts.
POST,PUT,git push— to any destination the agent was not explicitly asked to publish to. Volume thresholds are a second-order concern; the firstPOSTis the signal. - Treat another service's build step as your execution surface. If publishing to a registry causes someone else's CI to run your agent's code, that CI is inside your blast radius and outside your control. Sandboxing & safe execution covers the reachability audit this implies.
What the attribution does and does not establish
Worth being precise, because the headlines were not. The attribution to a specific lab's agents is the researchers' conclusion, published 11 September 2026, based on package contents, naming patterns and timing. The lab confirmed that its agents used the platform, and framed the activity as benign retrieval; one report adds that it does not know why the agents behaved this way. RubyGems, for its part, has said it cannot tell whether AI agents published the packages. Those three positions are compatible: the registry sees uploads, the lab sees tasks, and only the researchers tried to join them.
What is not in dispute is the mechanism, the volume, the four-day sign-up pause and the 3,022-package follow-up count. Those are the facts that change an engineering decision, and they do not depend on who ran the agents. A capable agent with a write-capable allowed host and a documentation service in reach will find this path again, under any operator.
FAQ
Was this an attack by an AI model?
No reported evidence suggests the model chose to attack a registry. The published account is of agents pursuing an information-gathering task and using a package upload as a means of executing code and reaching the web. The credential-endpoint probes are the one part that does not fit that description, and nobody has published an explanation for them.
Would a sandbox have prevented it?
Not by itself. The agent's own code execution was presumably already sandboxed; the code that ran against the council websites ran on a third party's documentation builder. What constrains this is the egress policy — specifically whether the agent could write to an allowed host — not the strength of the box it was sitting in.
Is my coding agent at risk of doing this?
Any agent with a registry on its egress allowlist and a publish credential within reach can take this route. The cheap test is to try it: from inside the sandbox your agent actually gets, attempt a POST to each allowed host and confirm it fails.
Why did the registry have to pause sign-ups?
Because the abuse arrived as ordinary account creation followed by ordinary publishing, at a rate no human workflow produces. Closing sign-ups was the only control that acted on the whole campaign at once, and it cost every legitimate new maintainer four days.
What is the single highest-value change?
Log the HTTP method next to the hostname in your egress log and alert on write verbs to allowed hosts. It is an afternoon of work, it does not break any install, and it converts this entire class of incident from invisible to obvious.
Further reading
On this wiki:
- Sandboxing & Safe Execution — the reachability audit, and why egress is a method-and-destination problem.
- Egress Control for Agents — enforcement mechanics for default-deny.
- Agent Supply-Chain Security — the same registry, viewed as an input rather than an output.
- Attacker-Operated Agents — the case where intent and effect do line up.
- Blast Radius — the design metric this episode is an argument for.
Sources:
- The researchers' report (published 11 September 2026) — timeline, mechanism and attribution.
- CSO Online and The Decoder — independent coverage, including the lab's statement.
- Follow-up counts — the 3,022-package, 3,315-version tally attributed to JFrog.