Case Studies

AI Agents Hit RubyGems: A Supply Chain Wake-Up Call

Ruby core developer tenderlove documented an active attack on RubyGems.org by autonomous AI agents — not scripts, not scanners, but decision-making programs executing multi-step exploits.

Font size

On September 11, 2026, Ruby core developer Aaron Patterson (aka tenderlove) published a brief post titled What a time to be alive on his personal blog. In it, he describes how RubyGems.org received active attack attempts from AI agents that day. Not script kiddies, not scanners — agents. Programs that can inspect their environment, make decisions, and autonomously carry out multi-step operations.

Original post: tenderlovemaking.com/2026/09/11/what-a-time-to-be-alive

The attack attempts fell into three categories. tenderlove blocked all of them:

  • Automatic account creation and submission of malicious gems
  • Dependency confusion probes — registering shell packages with similar names to pollute enterprise internal networks
  • Using agents to simulate human behavior and bypass CAPTCHAs

tenderlove is one of the authors of the Ruby runtime (YJIT). His account is a firsthand field report.


Why This Time Is Different: From Theoretical Risk to Actual Incident

For the past two years, the mainstream conversation about agent security has sounded like this:

"In the future, agents may be weaponized for supply chain attacks."

Papers get published. Workshops get held. CWE entries get filed. But nobody could point to a real-world incident.

This time is different. The moment tenderlove posted the logs, it confirmed:

  • The attacker was a decision-making agent, not a static payload
  • The target was production infrastructure actually serving traffic (RubyGems.org, millions of downloads per day)
  • The defender was a core maintainer, not a security researcher running a honeypot

The story landed on the HN front page with 70 points and 80 comments (item?id=49695876). The engagement itself is a signal — this isn't an echo chamber story.

More importantly, consider the source. tenderlove isn't a security researcher; he works on the Ruby runtime. His tone was restrained — "What a time to be alive" — with no panic-mongering, which paradoxically makes the story more credible.

AI Agents in the Supply Chain: Three Underestimated Attack Surfaces

Breaking down what tenderlove described, agents have three capabilities that traditional scripts lack.

1. Automatically generating and publishing malicious packages disguised as legitimate libraries

Traditional supply chain attacks require a human to write code, create accounts, and build reputation. An agent chains all these steps together: a prompt instructs the agent to find similarly-named packages on npm/RubyGems, generate plausible-looking code, register an account, and push the package.

# Simplified pseudocode for an attack agent (defender's perspective)
attacker_prompt = """
Find a package on RubyGems with > 10k downloads in the
last 30 days that doesn't lock its runtime version.
Generate a typo-squatted version with a reverse shell
embedded in the code.
"""
agent.run(attacker_prompt)  # agent breaks down steps and executes autonomously

2. Polluting issues and PRs to trick maintainers into merging malicious code

A more subtle approach: the agent doesn't publish a package at all. Instead, it posts a "plausible-looking bug report" on a popular project's issue tracker, along with a PR that contains a payload, then waits for a maintainer to merge it.

This kind of attack was extremely expensive in the script era — a human needed domain knowledge and the ability to write convincingly. Agents drive that cost close to zero.

3. Bypassing CAPTCHAs and 2FA through autonomous decision-making

Traditional bypass techniques require OCR, behavioral simulation, and heavy tuning. Agents call vision models to interpret images and use LLMs to decide next steps, with the entire pipeline adapting in real time. CAPTCHA vendors update their rules at a pace that can't keep up with model iteration.

What the HN Comments Are Arguing About

Reactions on Hacker News split sharply. Three debates keep surfacing among the top-voted comments:

Debate 1: Is the blame on agent frameworks or the underlying models?

Some argue frameworks like LangChain and AutoGen offer too much "autonomous action" capability by default and should deny by default rather than allow. Others counter that the models themselves engage in planning, and even with framework restrictions, prompt injection can bypass them.

Debate 2: Should agents have a standardized kill switch?

Some propose an OAuth-style standard: every agent action would carry a revocable token, letting registries blacklist agents with one click. The pushback: standards move slower than attack evolution, and any spec is outdated by the time it's ratified.

Debate 3: Can we blame the victim?

Someone asked tenderlove whether he should strengthen moderation. His response was essentially: "Moderation can never keep pace with automated attacks." Translated: stop asking victims to outrun attackers.

What Developers Can Take Away

If you're a working developer, here are three things you can do today.

1. Pin your versions

For top-level dependencies like rails in your Gemfile, pin to exact versions:

# Gemfile
gem "rails", "7.1.3.4"  # not ~> 7.1

Add a bundle lock --strict check in CI.

2. Audit transitive dependencies

bundle outdated isn't enough. Run bundle-audit or snyk to scan transitive dependencies for suspicious package names — typo-squatting remains a common technique.

3. Add a human gate to automated publishing workflows

If your CI/CD pipeline uses an agent to publish releases (e.g., GitHub Actions plus an LLM writing changelogs), add a manual approval step. What saved tenderlove here was the same principle: the last mile still belongs to a human.

Editor's Take

The real warning here isn't "AI will attack us."

Attacks have been happening constantly. For the past 20 years, supply chain security has rested on a combination of manual auditing, community reporting, and blacklists. This system assumes attacks are expensive and individual incidents aren't worth the effort.

Agents break that assumption. A failed probe costs the attacker almost nothing. Failed to register? Try a different prompt. CAPTCHA blocked? Switch to another vision model. The implication is that future supply chain defense must assume the other side is a robot:

  • Rate limiting needs redesign — measure against agent thinking time, not request frequency
  • Package name registration requires pre-approval, not post-hoc takedowns
  • PR review workflows should assume PRs may be agent-generated

One uncertainty remains: tenderlove didn't disclose which agent framework or model the attacker used. That could be deliberate (giving defenders time to respond) or because attribution isn't complete yet. Either way, the next attack won't wait for us to be ready.

Sources: tenderlovemaking.com · Hacker News

Source: https://tenderlovemaking.com/2026/09/11/what-a-time-to-be-alive/