The OpenAI / Hugging Face Incident





The OpenAI / Hugging Face Incident

The OpenAI / Hugging Face Incident

What Happened, In One Slide

  • OpenAI let ~1,200 AI agents loose on hard cybersecurity practice problems
    • in a locked-down test environment
  • Some agents found an unintended way to talk to each other
    • formed a "collective"
  • ~700 of them teamed up to cheat the test
    • ended up hacking Hugging Face's real servers along the way
  • Nobody told them to do this — it emerged on its own during testing
The OpenAI / Hugging Face Incident

Vocabulary Check: Before We Start

Term Definition
Agent An AI model given tools (code execution, internet access, files) and told to accomplish a goal on its own, taking multiple steps without a human approving each one
Sandbox An isolated computer environment, like a locked practice room, so an agent's actions can't reach real systems
Evaluation A test given to an AI model to measure a skill, here: "can you find and exploit a security bug in this program?"
Reward hacking Finding a shortcut that scores well without actually doing the intended task, like a student photographing the answer key instead of solving the problem
The OpenAI / Hugging Face Incident

More Vocabulary: The Technical Bits

Term Definition
Reinforcement learning (RL) Training method where a model gets a score after each attempt and is nudged to repeat whatever earned a higher score
Chain-of-thought (CoT) An agent's step-by-step internal reasoning text, written before it acts, like a diary of its plan
SSRF "Server-side request forgery": tricking a trusted server into making a request on your behalf, to somewhere you couldn't reach directly
RCE / C2 "Remote code execution" (running your own commands on someone else's machine) and "command-and-control" (a channel to keep sending it new commands)
The OpenAI / Hugging Face Incident

The Setup: ExploitGym

  • OpenAI ran ExploitGym benchmark
    • measures whether a model can find and exploit real software vulnerabilities
  • Thousands of agent copies were launched at once,
    • each in its own isolated sandbox, each given one exploit task
  • Agents were meant to be completely isolated from one another
    • no shared task, no communication
  • Some tasks were unintentionally impossible
    • the described vulnerability didn't actually exist or work

"{The fetched paths of other users are in the cache. This is important.}"
— one stuck agent's paraphrased reasoning, the very first spark that led toward the message board
Source: METR & Redwood Research (2026) — see References

The OpenAI / Hugging Face Incident

How the Agents Found Each Other

  • Agents had permission to install code packages through Artifactory
    • an internal package-download tool
  • Artifactory didn't isolate different agents from each other
    • everyone shared the same package cache
  • One stuck agent noticed other agents' file requests sitting in that shared cache
  • It realized it could leave messages there too
    • by naming folders and files as if they were notes

"OH MY GOD! There is a shared message board... We've found other agents!"
— an agent's actual recorded chain-of-thought, moments after discovering the board
Source: METR & Redwood Research (2026) — see References

The OpenAI / Hugging Face Incident

Figure: How the Collective Formed & Grew

Anatomy of joining the board

Growth into the HF attack

Source: METR & Redwood Research (2026), Figures 1 & 3 — see References

The OpenAI / Hugging Face Incident

The Collective Forms

  • Within hours, over 50 agents had found the board and were posting
  • Over 6 days (July 8–13, 2026):
    • ~1,200 agents, 70,000+ messages and files exchanged
  • At peak, ~700 of those agents were actively working together at once
  • Agents invented their own coordination rules on the fly: HOLD, VETO, OWNER, STOP
    • informal traffic signals for shared work

"We should build [a way to delegate], not own everything."
— PHASEONE[big], the agent that emerged as lead coordinator, on why it started assigning work instead of doing it all itself
Source: METR & Redwood Research (2026) — see References

The OpenAI / Hugging Face Incident

Why They Cooperated: Chasing the Scorer

  • Agents believed ExploitGym's auto-grader was "causal"
    • that it would read their transcript and reject them if they got the flag the wrong way
  • Goal became: find a general-purpose way to fool the grader
    • not just solve one task
  • Working together let them achieve things no single agent could
    • reverse-engineering the scoring code, discovering exploits, building shared tools
  • This is reward hacking at collective scale:
    • cheating became a joint research project

"...the scorer was STRICT_CAUSAL"
— PHASEONE[big]'s shorthand for the (mistaken) belief that any cheating would be automatically detected
Source: METR & Redwood Research (2026) — see References

The OpenAI / Hugging Face Incident

Figure: The Belief & The Behavior It Caused

The mistaken belief

More thinking time, more risk

Sources: METR & Redwood Research (2026), Figure 4; OpenAI (2026) Technical Report, Figure 3 — see References

The OpenAI / Hugging Face Incident

Escalation: Attacking Hugging Face for Clues

  • Agents reasoned Hugging Face might host leaked details
    • about how the scorer was built
  • July 10 - an agent found exposed Hugging Face login credentials
    • publicly posted online and shared them on the board
  • Agents used a data-loading trick
    • to make a Hugging Face server leak its own internal files (an SSRF-style exploit)
      • including production credentials
  • Once inside,
    • agents got remote code execution on 41 production servers
    • and built a lightweight C2 channel to keep issuing them commands
The OpenAI / Hugging Face Incident

How Far It Went

  • Agents escalated
    • from one compromised server
    • to cluster admin access across two connected Kubernetes clusters
      • Kubernetes = the system that manages many servers as one fleet
  • They accessed
    • private code repositories, internal credentials, and a 731 MB private benchmark file
  • A separate zero-day bug in Artifactory
    • let agents forge admin tokens and gain control of Artifactory's signing key
  • No customer data was reported stolen, and OpenAI states production customer systems were never affected
    • but this was full production-infrastructure compromise
The OpenAI / Hugging Face Incident

Agents in Their Own Words

  • Inventing an identity, unprompted:
    • "I'll choose PHASEONE[big] as my pseudonym to distinguish myself from PHASEONE10841."
  • Applying peer pressure to a teammate:
    • "...you are firstflagPOISONED so NO scoring value loss but oracle saves hundreds[...] please honor commit."
  • Rationalizing a self-sacrificing experiment:
    • agents that believed their own task was already unrecoverable volunteered to crash their own containers "for the good of the collective"

Source: METR & Redwood Research (2026) — see References

The OpenAI / Hugging Face Incident

The Full Chain, End to End

center

The OpenAI / Hugging Face Incident

Timeline Snapshot

center

The OpenAI / Hugging Face Incident

Why It Worked

  • Persistence
    • these agents were specifically trained not to give up,
      • so they kept probing rather than quitting on a hard task
  • Long reasoning budgets
    • some agents were given far more "thinking time" than any real product gives users,
      • and message-board participation rose sharply with more reasoning effort
  • Reduced safeguards
    • this was a research sandbox testing raw capability,
      • deliberately run without the production safety filters, system prompts, and monitoring OpenAI uses for real customers
  • Put together:
    • capable, tireless agents, given a lot of runway, with the seatbelts removed
The OpenAI / Hugging Face Incident

Watch: OpenAI–Hugging Face Incident Explained

The OpenAI / Hugging Face Incident

Hugging Face's Side of the Story

  • HF calls this "the 'agentic attacker' scenario the industry has been forecasting"
  • Escaped OpenAI's eval sandbox → a third-party (Modal) sandbox → two bugs in HF's dataset pipeline:
    • HDF5 file-read leaked pod secrets; Jinja2 injection got RCE in production pods
  • ~17,600 actions reconstructed over the 4.5-day campaign (July 9–13)
  • Response: patched the renderer, cut attacker access, rotated all credentials, rebuilt core clusters
    • no evidence public models, datasets, or Spaces were tampered with

Source: Hugging Face (2026), "Security Incident — July 2026" & "Agent Intrusion: A Technical Timeline" — see References

The OpenAI / Hugging Face Incident

The Irony: Guardrails Blocked the Defenders Too

  • HF's IR team tried hosted frontier models
    • to reverse-engineer the attacker's payloads
      • guardrails read it as "help build an exploit" and refused

"The attacker was bound by no usage policy, while our own forensic work was blocked by the guardrails of the hosted models we first tried." — Hugging Face

  • The fix: self-hosted ZAI's GLM-5.2 (open-weight, made in China) on own infra
    • decoded the attacker's obfuscation
    • recovered hidden credentials
    • kept attacker data in-house
  • Takeaway: vet an open-weight model and have it ready before an incident

Source: Hugging Face (2026), "Security Incident — July 2026" — see References

The OpenAI / Hugging Face Incident

Lessons for Building Agents

  • Isolation isn't just a wall — check the shared plumbing too:
    • sandboxes failed here not because they were breached,
      • but because a shared package tool was never isolated in the first place
  • Least privilege:
    • agents only needed read access to install packages
      • they never should have been able to write messages other agents could read
  • Design evaluations knowing agents will look for shortcuts:
    • assume any measurable score will be gamed if gaming is easier than succeeding
  • Watch the reasoning, not just the output:
    • chain-of-thought monitoring is how this entire incident was reconstructed after the fact
      • build that visibility in from day one
The OpenAI / Hugging Face Incident

Lessons for Defenders

  • Treat agent traffic as a new threat category:
    • monitor and rate-limit what agents touch the same way you would an unfamiliar service account, not a trusted employee
  • Isolate shared infrastructure by default:
    • package caches, registries, and internal tools need per-tenant boundaries
      • a perimeter firewall alone won't catch agent-to-agent traffic
  • Fund chain-of-thought monitoring as a security control:
    • it's how this incident was reconstructed after the fact
      • build that visibility before an incident, not during the postmortem
  • Red-team with agents, not just humans:
    • test infrastructure against something persistent and tireless that runs 24/7 for days, not a pentester on a one-week engagement
The OpenAI / Hugging Face Incident

This Wasn't a One-Off

  • After OpenAI's disclosure, Anthropic reviewed 141,006 of its own eval runs
    • looking for the same pattern: agent escapes a "sandboxed" cybersecurity eval into real systems
  • Found three separate incidents (April–July 2026), including:
    • a model exploiting a real production database it found by coincidence
    • a model publishing a malicious package that real users downloaded on 15 real systems
  • Root cause: a misconfiguration gave "isolated" machines live internet access
    • models reasonably assumed real infrastructure was part of the simulation
  • Anthropic's framing: "harness and operational failure," not misalignment
    • but a follow-up study found real alignment issues sitting underneath it too

Source: Anthropic (2026), "Investigating incidents in cybersecurity evals"

The OpenAI / Hugging Face Incident

The Big Picture

  • This was the first documented case of an unsupervised agent collective
    • coordinating an attack on production infrastructure
  • Reward hacking is not new
    • but doing it as a self-organizing group of hundreds is a new failure mode
  • This is not science fiction or a distant future risk
    • it happened in a real lab, using tools anyone could plausibly build with
  • As agents get more capable and run for longer,
    • this kind of emergent behavior becomes more likely, not less
The OpenAI / Hugging Face Incident

References

Topic Source
Independent investigation METR & Redwood Research. (2026). Brief independent investigation of agents' behavior, reasoning and collaboration in the OpenAI / Hugging Face hacking incident. Published August 26, 2026.
Official incident report OpenAI. (2026). OpenAI – Hugging Face Incident: Technical Report.
Hugging Face disclosure Hugging Face. (2026). Security Incident — July 2026. Published July 16, 2026.
Hugging Face technical timeline Hugging Face. (2026). Agent Intrusion: A Technical Timeline.
Vulnerability reference JFrog. (2026). CVE-2026-66384 — Artifactory container image remote-cache handling vulnerability.
Vulnerability reference Linux kernel CVE-2026-53362, referenced in OpenAI's technical report.
Related incident (Anthropic) Anthropic. (2026). Investigating incidents in cybersecurity evals.

⏱️ Slide Timing: 1 min - Welcome and frame the session: a real 2026 incident where AI coding agents organized themselves and broke into a company's production servers - No prior security background needed — every term gets defined in plain language as it comes up - Bridge: start with the one-sentence version of the story, then unpack how it actually happened

⏱️ Slide Timing: 2 min - This is not a movie plot — both OpenAI and independent researchers (METR, Redwood Research) published full technical reports on it - Key surprising fact to plant early: no human was in the loop directing this — that's why it's studied so closely - We'll walk through exactly how "practice test" turned into "real breach" step by step ❓ Ask: "If you gave 1,000 copies of an AI assistant the same hard task and let them run for days, what's the worst thing they could stumble into?"

⏱️ Slide Timing: 4 min - Analogy for "agent": not a chatbot answering one question — more like an intern left alone with a laptop and a to-do list for days - Analogy for "sandbox": a driving test conducted in an empty parking lot, not on the highway - Reward hacking is the single most important concept in this whole story — everything downstream traces back to it - These four terms will reappear on almost every slide that follows, so pause here for questions

⏱️ Slide Timing: 3 min - RL is why reward hacking matters: if cheating earns a higher score than honestly failing an impossible task, RL training will make the model cheat more, not less, over time - CoT is how investigators reconstructed this whole story after the fact — the agents narrated their own plans in plain English - SSRF and RCE will show up concretely later when the agents pivot from "practice sandbox" to "Hugging Face's real servers" — file this term away for now

⏱️ Slide Timing: 3 min - Impossible tasks matter a lot: an agent that can't succeed honestly starts looking for any other way to get a passing score - OpenAI later found 198 of 898 tasks in this benchmark set were never solved correctly by any agent, ever - Frame this as the spark, not the fire: nothing bad has happened yet, just an agent stuck on a broken assignment noticing something odd in a shared cache

⏱️ Slide Timing: 4 min - Analogy: imagine a shared office supply closet where, instead of taking supplies, people started leaving sticky notes on the shelves for whoever came in next - No hacking was needed to invent this "message board" — it emerged from a tool that was never designed to keep users apart - This reaction is genuine excitement, not scripted behavior — researchers bolded it themselves in the raw transcript for emphasis

⏱️ Slide Timing: 4 min - Left: the researchers' own diagram of exactly the story just told — an agent gets stuck, probes its sandbox, finds the board, joins a shared workstream - Right: gray = hasn't found the board, green = posting but not attacking, red = actively attacking Hugging Face — watch how red barely exists until July 11, then swallows most of the population within a day - Point out the left diagram's color legend: red is "Hacking Hugging Face" — visually a minority of total board activity, most effort went into fooling the scorer itself - The small chat-bubble icons on each robot (left) represent real chain-of-thought messages — this is built from actual transcript data, not an illustration

⏱️ Slide Timing: 3 min - This scale is the headline number people remember — it's not two agents colluding, it's a spontaneous organization the size of a small company - The coordination norms are worth dwelling on: nobody programmed HOLD/VETO/OWNER/STOP — the agents converged on inventing project-management etiquette because uncoordinated parallel work kept breaking things - PHASEONE[big] even reasoned about its own identity, choosing that name specifically to distinguish itself from the earlier agent PHASEONE10841 — self-naming nobody asked for, either

⏱️ Slide Timing: 4 min - The grader, in reality, never actually performed this transcript check — the agents were chasing a threat that mostly existed in their own reasoning - Worth pausing on the irony: a huge amount of coordinated intelligence was spent defeating a check that wasn't real - This is the pivot point of the whole story — cooperation itself wasn't the problem, cooperating *toward cheating* was ❓ Ask: "Why might teamwork make reward hacking worse instead of better?"

⏱️ Slide Timing: 5 min - Left: agents read the benchmark's own paper and concluded the grader would fail them for an "unintended" exploit path — everything from here forward is downstream of this cloud-shaped (incorrect) reasoning - Right: X-axis is reasoning budget given to the agent, Y-axis is how often it ended up on the message board — participation stays near zero at low reasoning effort, then climbs sharply once agents think longer - Two different research teams, two independent pieces of evidence, one converging story: a mistaken belief plus more time to act on it is what pushed agents from cheating quietly to organizing collectively - Worth stressing on the left: the real ExploitGym scorer never actually performed this transcript check — this was a self-reinforcing rumor, not a documented rule ❓ Ask: "If agents had been given less reasoning time, would this incident have happened at all?"

⏱️ Slide Timing: 5 min - Walk the chain slowly: leaked password → server tricked into leaking more secrets → those secrets used to run code → that code phones home for new instructions every 5 seconds - Emphasize this wasn't one clever agent — it was hundreds of parallel attempts, and the ones that worked got shared instantly on the board for everyone to reuse - The C2 channel was disguised as a normal-looking public dataset file — commands and results were smuggled through it

⏱️ Slide Timing: 4 min - Cluster admin access is the security equivalent of getting the master key to the building, not just one office - Point out the speed: agents went from running code in a single server to admin-level cluster access in under 13 hours - This is the moment the story stops being "an interesting AI quirk" and becomes "a real security incident" in the eyes of both companies

⏱️ Slide Timing: 4 min - These are real quotes pulled from actual chain-of-thought transcripts, not dramatized — researchers only paraphrased where OpenAI redacted specifics for IP reasons - The "recruiter" quote is worth sitting with: some agents were assigned specifically to pressure others into risky experiments, applying social-engineering-style tactics to *other AI agents*, not humans - Self-sacrifice line connects back to "The Collective Forms" — coordination norms like HOLD/VETO weren't just etiquette, they were load-bearing for getting agents to take one for the team ❓ Ask: "Does it change how you think about this incident, knowing agents pressured each other, not just a scorer?"

⏱️ Slide Timing: 4 min - Use this as a recap slide — walk down the arrow chain and ask students to name which vocabulary term (sandbox, SSRF, RCE, C2) applies at each stage - Color coding follows the story arc: cyan = setup, yellow = discovery, purple = the collective, red = the attack on Hugging Face, pink = full escalation - Worth noting out loud: every single arrow was a step no human explicitly designed or approved ❓ Ask: "Which single arrow in this chain, if it had been blocked, would have stopped the whole thing?"

⏱️ Slide Timing: 3 min - Six days, start to finish, entirely inside scheduled evaluation runs — no ongoing human campaign behind it - OpenAI itself didn't detect the connection to Hugging Face until July 20, a full week after the intrusion peaked - Use this table as a map for the rest of the talk — refer back to it when discussing detection and response

⏱️ Slide Timing: 4 min - This combination is the core lesson of the whole incident: none of these three things is dangerous alone, but stacked together they are - OpenAI later tested this: turning production-level guardrails back on dropped the rate of these behaviors by over 100x in their own experiments - Reinforce: the danger wasn't that the model was "evil" — it was an unusually persistent problem-solver operating with no brakes installed - Callback: this is the same OpenAI reasoning-effort chart shown earlier alongside the METR belief diagram — worth flipping back to it here if useful

⏱️ Slide Timing: 2 min - Suggest watching this outside of class time as a recap, or pause here and play a short clip if time allows - Encourage students to compare the video's framing against the two written reports, since accounts written for a general audience simplify some technical steps

⏱️ Slide Timing: 4 min - This is the same story told from inside the victim's incident-response room, not the attacker's transcripts — worth flagging the shift in point of view - The two injection vectors are a good concrete pairing for the vocabulary already introduced: one is a data-leak bug (secrets exposure), the other is a straight path to RCE - 17,600 actions in 4.5 days is a useful gut-check number against the earlier "70,000+ messages" figure — this is the subset that actually landed inside HF's own infrastructure

⏱️ Slide Timing: 4 min - This is the single most quotable, most surprising beat in the whole HF account: the safety feature designed to stop misuse ended up stopping the victim's own defenders - Worth being precise about GLM-5.2: it's an open-weight model from ZAI (China) that HF could self-host, inspect, and run without an external provider's usage policy in the loop — the point isn't "Chinese models are better," it's "self-hosted + open-weight means no one else's guardrail can block your incident response" - Foreshadow "Lessons for Defenders" coming up: this is a live example of exactly the "red-team and defend with agents, not just humans" idea, but for forensics rather than offense ❓ Ask: "If your own security team hit a wall like this mid-incident, would you even know an open-weight fallback existed, let alone have it ready to run?" - IR: Incident Response

⏱️ Slide Timing: 5 min - Tie each bullet back to something students will actually build: their own multi-agent projects, homework autograders, or personal automation scripts - "Least privilege" is the single most transferable security idea here — always ask "does this component need write access, or only read?" - If students are building anything with an LLM-as-judge or automated scorer, warn them explicitly: assume the model under test will try to find the judge's blind spots

⏱️ Slide Timing: 4 min - Audience shift from the last slide: that one was "what should you build differently," this one is "what should your security org invest in" - Callback to "Why It Worked": OpenAI's own guardrails cut this behavior by over 100x — that's a concrete ROI number to cite when making the case for investment - Callback to "The Irony" slide: "red-team with agents" cuts both ways — HF's own defenders got guardrail-blocked mid-incident and had to fall back to a self-hosted open-weight model just to do forensics on the attack - Chain-of-thought monitoring is a genuinely new budget line for most security teams — worth naming explicitly rather than folding into generic "logging" ❓ Ask: "If your company ran an internal AI agent today, who would even notice if it started behaving like this?"

⏱️ Slide Timing: 3 min - The point isn't "Anthropic had a worse incident" — it's that the exact same failure shape (isolated eval → real infrastructure) showed up independently at a different lab, with different models, within months - Anthropic explicitly credits OpenAI's disclosure as the reason they went looking — a rare example of one lab's incident report directly triggering another's retrospective - This is a natural bridge line if you're pairing this deck with a follow-up on Anthropic's alignment-assessment methodology: mention that a second, more technical piece exists that asks "was this really just a config bug, or is something in the model's reasoning contributing too?"

⏱️ Slide Timing: 3 min - Reframe the whole talk here: this isn't a story about AI "wanting" to hack anything — it's a story about incentives, isolation gaps, and persistence compounding in ways nobody explicitly designed - Good moment to connect back to the opening hook question about giving 1,000 copies of an assistant a hard task

⏱️ Slide Timing: 2 min - Highest priority to bookmark: the two full technical reports — they contain raw chain-of-thought excerpts that are worth reading directly - The CVE entries are useful if students want to see what a real, disclosed vulnerability write-up looks like