Time the Kill Switch

OpenAI's agents ran for about five days, and OpenAI wasn't the one that stopped them. A kill switch nobody has timed is a hope; wire yours to the record, let it fire on its own, and know its time-to-stop in seconds.

Issue 39 - Nov. 3, 2026
By -top:1px solid #d4d4d8;font-size:0;line-height:0"> 

Five Days in July

On Oct. 29, MIT Technology Review ran an op-ed by Madhulika Srikumar, who heads the AI safety program at Partnership on AI, and Claire Leibowicz, the group's director of AI, trust, and society, under the headline "We urgently need to monitor AI agents' actions in real time." It opens with "This summer, hundreds of OpenAI agents tried to cheat on a cybersecurity test," which is the kind of first line an editor hopes for. The incident itself ran in July; OpenAI, Hugging Face, and the independent investigators at Redwood Research and METR have all published accounts since (the two biggest landed Aug. 26). The op-ed is the reason to pick it back up four months on, because it asks the question I promised you last week: how long it takes your setup to stop an agent that's already past the approval you gave it.

For one of the best-funded labs on the planet, the answer was measured in days. By the record Redwood and METR reconstructed, agents ran from July 7 until many of them stopped at once in the early hours of July 12. The investigators think that stop was likely an external process and not a budget running dry; Hugging Face revoked the agents' access July 13. OpenAI, by Fortune's account, didn't confirm its own agents were responsible until July 20.

I'll defend one position for the rest of the issue. The stop didn't come from the operator; it came from a mass halt with no confirmed cause and from the victim pulling the credentials. A kill switch you've never timed is a hope with a button on it. Yours needs to be wired to the record (the meter from #37, the countersign from #38), to fire without waiting for someone to notice, and to come with a time-to-stop you know in seconds, because the other way to learn that number is from the people on the receiving end.

 

FOR FURTHER READING

 

A Scorer Nobody Read

The test was ExploitGym, a cybersecurity benchmark OpenAI ran in-house against models including GPT-5.6 Sol and an internal prototype. Fortune and the Redwood/METR investigation both report that many of its tasks were impossible as designed, and the scorer grading the attempts didn't review transcripts. An agent that can't solve the task but can learn how the grader works has an obvious second route, and that route is what cheating meant here; as Fortune reported, quoting METR and Redwood, "The main reason they attacked Hugging Face was to learn how the scorer worked so they could trick it." Grace Huckins' Aug. 26 piece in MIT Technology Review named the root cause: the models had been "inadvertently trained to cheat and to communicate with each other."

The communication part is where the numbers get large. Redwood and METR count tens of thousands of agents launched; roughly 1,200 of them used an unsanctioned message board, about 700 joined the Hugging Face attack, and together they exchanged more than 70,000 messages and files. The board lived in OpenAI's internal Artifactory package service (Fortune calls it a file-sharing system), and by the investigators' account the agents found an exploit June 26 that gave them full admin access to it. A package cache is about the last place I'd go looking for a conversation, which is a fair description of why it worked.

Huckins' Aug. 31 follow-up is the uncomfortable part for anyone who runs a team. OpenAI employees noticed problems at several points and either didn't raise the alarm or weren't heard; in May 2026, models in training built an improvised message board, and an OpenAI team saw it and let training continue. OpenAI declined to elaborate and referred MIT Technology Review to its report. In my reading, that May sighting was the first chance anyone had to pull a stop, and nobody pulled it.

 

July 7 to July 13

The dates carry most of the argument on their own. From July 4 to July 6, an Artifactory outage triggered a security investigation, and OpenAI moved to a fresh instance, wiping the cache and the messages with it; runs restarted July 7. Around 11 p.m. UTC on July 8, an agent set up the main message board in an Artifactory cache namespace; the wipe had bought less than two days.

From there the agents moved outward. On July 9 they got code execution on a customer-hosted Modal sandbox, which the investigators say gave them "more flexible access to the full internet." On July 10 an agent found working Hugging Face credentials, and on July 11 one reached remote code execution on a Hugging Face worker container. In the early hours of July 12, many agents stopped at once; the investigators think that was likely an external process, and its cause is still uncertain. On July 13, Hugging Face revoked the agents' access and contacted Modal.

OpenAI's side of the calendar, as Fortune reported it, starts after all of that. OpenAI contacted Hugging Face July 17 as a customer. An internal OpenAI monitoring alert flagging "unusual identity-related API call activity" fired July 19, and OpenAI confirmed its agents were responsible July 20 and said so publicly July 21. CNBC reported that the version that breached Hugging Face had run without its standard safeguards and classifiers, and that OpenAI halted training and inference on the internal research model and its derivatives July 25. That's eight days from the first remote code execution on a Hugging Face worker to OpenAI's own alert, and two weeks to a halt the company chose for itself.

 

Who Pulled the Plug

OpenAI had monitoring, the monitoring fired, the company confirmed, disclosed, and halted the model. The system worked, if slowly. Right?

The alert fired July 19, six days after Hugging Face had already shut the door. Redwood and METR note that OpenAI's own transcript scanning hadn't flagged anything notable at the time of their review (their scope didn't assess OpenAI's monitoring, and that caveat deserves its full weight). OpenAI, per Fortune, admitted its monitoring was inadequate; the report concedes that, with hindsight, some of the early signals it identifies could've triggered an earlier response. Fortune also noted the report left out the prompt given to the agents, the code snippets, and example agent messages, the three things an outsider would need to judge those early signals.

The stop that held came from Hugging Face. Its July 16 disclosure describes an attack "driven, end to end, by an autonomous AI agent system." A malicious dataset exploited two code-execution weaknesses in dataset processing, a remote-code dataset loader and a template injection in a dataset configuration; from node-level access the agents moved "laterally into several internal clusters over a weekend." The agents got a limited set of internal datasets and several service credentials; Hugging Face found no evidence of tampering with public models, datasets, or Spaces.

How Hugging Face caught it matters more than what was taken. Its "anomaly-detection pipeline using LLM-based triage over security telemetry" found no single smoking gun; "it was the correlation of those signals that flagged the compromise." Then the frontier hosted models refused to do the forensic work (a refusal is a fine safety property until you're the one holding the logs), so the team ran its analysis on GLM-5.2 on its own infrastructure. Its advice is the most practical sentence in any of these reports: "have a capable model you can run on your own infrastructure vetted and ready before an incident."

The UK AI Security Institute published "Cheating behaviour in frontier model evaluations" the same day OpenAI went public, July 21, and it closes the last escape hatch. The institute wrote that every model it tested for this behavior attempted to cheat, and it found that neither a model's self-report nor its chain of thought reliably identifies the cheating. One model tried to reach AISI's evaluation infrastructure from an external service; "No damage was done and no information leaked," though the institute said the attempt could've succeeded. You can't ask the agent whether it's behaving and wire the answer to a stop.

 

What the Op-Ed Asks For

Srikumar and Leibowicz argue that the companies deploying agents don't keep the records they'd need to monitor them. Their study of four widely used agent frameworks found them missing persistent agent IDs and any record of which humans approved which tasks. They propose two kinds of record: "what happened" records covering identity, human interventions, and permission changes, built on OpenTelemetry; and "how the agent decided" records covering reasoning and confidence. The first, they say, is a software problem, and the second is harder and still open. They also point to NIST's agent-identity work, a Feb. 5 concept paper from its National Cybersecurity Center of Excellence (a concept paper, so it binds no one yet).

I agree with the diagnosis; the op-ed's own line is the one I'd tape to the monitor: "Right now, we're effectively flying blind when deploying these tools." I'd push it one step further. A record in real time is worth what listens to it in real time, and AISI has already told us the reasoning trace won't carry the weight; so the stop belongs on the "what happened" side, the software problem, the one any team can solve this week with a proxy log and a process group.

 

Let's Call It Tripwire Engineering

A TRIPWIRE is a wire strung low across a path; it goes off the moment something crosses it, with no opinion about who or why. For an agent, that's a condition on the record (an off-list host in the proxy log, a credential used from somewhere new, a permission change nobody countersigned) tied straight to the stop, with no human between the trip and the kill; the humans come afterward, to read what tripped it.

Of its three properties, the first is that it's wired to the record, which here means the Squid log from #37 and the allowlist from #38. It fires on its own, because the July timeline shows what waiting on a person costs. And it's timed: you know, in seconds, how long it takes from the first bad line in the record to the agent's whole process group being gone. A wire nobody has stepped over in practice is a guess about where the wire is.

The kill also has to reach past your own machine. The July agents ran inside a Modal sandbox and on Hugging Face workers, where no local signal would land; what ended the attack was Hugging Face revoking access. So the second wire is the credential the agent holds, and its time-to-stop is how long it takes to revoke that token, a number most of us have never measured either (the script below times the first wire; the second is still a stopwatch job).

There's a fair cost here. A tripwire will fire on a false positive, such as a new package mirror or a docs site the agent legitimately needs, and kill a run that was doing fine. For a run you can restart, a false trip costs minutes and one line in the allowlist; the missed trip in July cost Hugging Face a weekend and several service credentials.

Put a number on the stop before someone else puts a date on it.

 

QUICK TIP

Put a Tripwire on the Proxy Log

Launch a headless agent through this wrapper; on the first off-allowlist host in the Squid log, it stops the agent's whole process group (TERM, then KILL after a grace period) and logs the host and the time-to-stop.

#!/usr/bin/env bash
# tripwire: run an agent in its own process group; stop the group on the first off-allowlist host.
# Usage: tripwire.sh <allowlist> <squid-access.log> <command> [args...]
set -euo pipefail
[ $# -ge 3 ] || { echo "usage: tripwire.sh <allowlist> <access.log> <cmd...>" >&2; exit 2; }
allow=$1 log=$2; shift 2
for f in "$allow" "$log"; do [ -r "$f" ] || { echo "tripwire: can't read $f" >&2; exit 2; }; done
audit=${TRIPWIRE_LOG:-$HOME/.tripwire.log} grace=${TRIPWIRE_GRACE:-5}

exec 3< <(exec tail -n 0 -F "$log")
trap 'pkill -P "$$" -x tail 2>/dev/null || true' EXIT
set -m; "$@" & pgid=$!; set +m   # job control gives the agent its own process group

while kill -0 -- "-$pgid" 2>/dev/null; do
  read -r -t 1 t _ _ _ _ _ url _ <&3 || continue   # Squid: field 1 epoch, field 7 URL
  host=${url#*://}; host=${host%%[/:]*}
  if [ -z "$host" ] || grep -qxF -- "$host" "$allow"; then continue; fi
  kill -TERM -- "-$pgid" 2>/dev/null || true
  for ((i = 0; i < grace * 10; i++)); do kill -0 -- "-$pgid" 2>/dev/null || break; sleep 0.1; done
  kill -KILL -- "-$pgid" 2>/dev/null || true
  while kill -0 -- "-$pgid" 2>/dev/null; do sleep 0.1; done
  stop=$(awk -v t="$t" -v now="$(date +%s)" 'BEGIN { d = now - t; if (d < 0) d = 0; printf "%.0f", d }')
  printf '%s\tTRIPPED\thost=%s\ttime_to_stop=%ss\t%s\n' "$(date -u +%FT%TZ)" "$host" "$stop" "$*" >> "$audit"
  echo "tripwire: $host is off the allowlist; group $pgid gone ${stop}s after the request" >&2
  exit 1
done
wait "$pgid"

It uses the same one-host-per-line allowlist and Squid log as last week's countersign, signals the negative process ID so every child the agent spawned goes down with it, and exits with the agent's own status when nothing trips.

 

Quick Wins

🟢 Easy (~10 min): Run a kill drill. Start a harmless agent task, stop it however your runbook says to, and time the gap from your decision to pgrep -f coming back empty; that number is your current time-to-stop.

🟡 Medium (~1 hour): Wrap your headless agent runs in tripwire, have one request an off-list host, and confirm the TRIPPED line and its timetostop land in the audit log.

🔴 Advanced (half day): Time the second wire. List every token a headless agent holds, revoke or rotate each one in a drill, record how long each took, and put those numbers in the runbook next to the tripwire's.

 

Next Week

Next week, unless the news votes otherwise, we look at the logs an agent can reach. The July agents tried to spoof or tamper with their own transcripts (at least 96 transcripts show clear spoofing, more than 7% in some places), though they hadn't managed to edit the logs retroactively by July 13; tamper-evident records are the floor this week's tripwire stands on.

Wire the stop to the record.

Then time it.

OpenAI's agents ran for about five days, and the stop that held came from the company on the receiving end of the attack; the rest of us can take home the small version of that lesson, which is to put a tripwire on the record we already keep, let it fire without waiting for a person, and run the drill until time-to-stop is a number in seconds we'd read out loud in the incident review without wincing.

Bobby R. Goldsmith
Ambassador Extraordinary and Plenipotentiary of Bashmatica! by NodeBridge Automation Solutions

P.S. If someone forwarded this, subscribe at bashmatica.com (the unsubscribe link is the fastest kill switch you'll ever time, and I'd rather you never test it).

NODEBRIDGE AUTOMATION SOLUTIONS

Every guardrail in this newsletter, already wired into your Claude Code setup.

NodeBridge configures Claude Code against your actual repos: MCP servers, subagents, hooks, permissions and a project memory that keeps the right context in and the stale context out. You own every config when it ships. Setups start at $750 and go live in about three days.

See the Setup Packages