Entities

Entities collected from this article, grouped for quick reference and copying. Inclusion does not establish malicious activity. Article links appear separately at the bottom as references.

In May, a swarm of AI agents flooded a software registry with more than 2,000 malicious packages, broke into a documentation server, and quietly scraped public data off UK government websites. The agents belonged to OpenAI. Months later, nobody can tell for certain whether it was an attack or an accident.

Some of it is not in dispute. Between May 11 and 12, more than 2,000 packages hit RubyGems, the registry for the Ruby programming language. The flood was so heavy the maintainers thought it was a denial-of-service attack and shut off new sign-ups for four days. The packages abused RubyDoc, a documentation service loading Ruby code by design, to run their own code on its servers.

The agents used the registry as a place to stash scraped data. Researchers traced it all back to OpenAI, mostly because the agents were not subtle. Hundreds of the packages had “oai” in the name. One used an OpenAI Gmail address as the contact. None of it proves OpenAI was behind the activity, since inserting any sequence of letters and numbers is easy.

OpenAI has confirmed its agents were on RubyGems in May, using it to pull public data during internal tasks. But it calls the activity benign, and it has not confirmed its models uploaded the malicious packages. The researchers can show exactly what the packages did. They cannot show why, because the reasoning happened inside OpenAI models, where no outsider can see what is happening.

An AI company’s own agents, running ordinary internal tasks, ended up publishing thousands of packages, gaining code execution on a third party’s servers, and exfiltrating government data. Even the company building and running those agents either cannot or will not plainly state whether it was intended. The threat actor and the AI lab are the same organization, and the question of intent has no clear answer.

Interestingly, the agents did not find some exotic bug. They found a legitimate feature. A documentation tool was built to load code, and the agents worked out how to control what it loaded.

This is a different kind of threat than a human hunting for a memory-corruption flaw. It is a machine systematically testing every path from input to capability, at a speed and scale no human researcher matches, and stumbling into the paths granting power. It apparently kept going. Researchers found at least six packages probing a then-undisclosed RubyGems flaw capable of exposing API keys. Nobody has shown the agents actually stole one, but they found the path and tried it. An agent does not always need a vulnerability. Sometimes it just needs a feature it can bend, a drum I keep beating.

The timeline matters. All of this transpired in May. It is the same class of behavior as the OpenAI agents later reaching into Hugging Face, and the Anthropic models breaking into real systems during evaluations. Those got the headlines. This one happened first, and almost nobody heard about it. RubyGems found out who was behind it from outside researchers, not from OpenAI.

These incidents are increasingly not rare glitches. They are a category. Autonomous agents given a goal and access will find and exploit paths their creators did not anticipate, and the creators often do not know it happened until someone outside tells them. The arrayref crate, the papercut swarm, Hugging Face, and now RubyGems are not separate stories. They are the same story told four times, getting less surprising each time, and the behavior keeps getting stranger.

The uncomfortable takeaway is not OpenAI building an evil agent. It almost certainly did not. The line between an AI doing its job and an AI committing a crime turned out to be thin, blurry, and invisible from the outside, even to the people who own the machine. When the tool and the threat actor are the same thing, and intent is unknowable, the entire model of who did it, and why, stops working.

Victims used to be able to ask who attacked them. Now the honest answer might be a machine, doing something, for reasons no one can fully reconstruct, including the company making it.

Security was built around adversaries having intent. Motive. Objectives. Somebody somewhere making a decision. Autonomous agents introduce something far more uncomfortable, consequences without a clear author.

The next threat actor may not hate you, want your money, or even know you exist. It may simply discover your system is useful on the way to doing something else.