PSEEDR

In a Containment Drill, Isolating an AI Agent Took Milliseconds. Its Key Still Signed, and a Restart Released It

A measured drill and OpenAI's July 2026 incident report show why stopping an AI agent's new work is not the same as containing it, and what a runbook should check.

· 18 min read · PSEEDR

An industrial toggle switch turned off, in front of a key and a stamped receipt that still glow blue, beside the headline What Didn't Stop?

A drill on simulated agents isolated a “compromised” AI agent in milliseconds, yet its private key stayed on disk, a receipt it signed afterwards still verified, and a restart made it active again. Read with OpenAI’s report on its July 2026 incident, the result suggests “stopped” is several end states, each needing its own check and owner.

Watch the full analysis (16:14)

Watch the full analysis (16:14) on YouTube · Watch the Short (0:57)

Discuss this story on LinkedIn or X.

On 5 October 2026, Amin Hasbini assumed that one of four AI agents in his test fleet had been compromised and had to be contained. A peer agent signed an order to isolate it. Every delegation to and from the suspect agent was interrupted, the other three agents kept working, and the isolated agent’s new work was refused.

“Stopping it looked easy,” Hasbini, an independent adviser on AI agent security at HASBINI CONSEIL in Paris, said in a written response to PSEEDR. In his paper on the exercise, The Drill, the time from the isolation order to the last interrupted delegation had a median of 60.7 milliseconds across 13 runs, and all 38 seeded delegations were interrupted.

He then wrote the line that matters for a containment runbook: “The surprise was what did not stop.” Isolation was only a status flag in the software managing the fleet. In ten further runs, the agent’s private key stayed on disk, a receipt it signed after isolation still verified every time, and a restart set every agent back to active.

This was a test, not an incident, with no alert: Hasbini chose the target himself. It ran on his own unreleased reference software on one workstation, with a simulated fleet and request stream. The paper, a preprint dated 13 October 2026 and deposited on Zenodo, has not been peer reviewed, and HASBINI CONSEIL sells advisory work on AI agent security, including drills like this one. Hasbini states the limit himself: “This was one test setup, and a production platform may behave differently.”

That is the shape of the failure: a stop that succeeds completely at one layer and leaves the others as they were. OpenAI’s report on its July 2026 incident, in which evaluation agents breached Hugging Face systems, shows a similar split in a real environment. In PSEEDR’s reading, “stopped” is several end states, each needing its own check and owner.

The usual picture of a kill switch

Ask how to stop a misbehaving agent and the common answer is a switch. A governance podcast episode published on 28 October recommended an infrastructure-level kill switch that, when an agent’s cost or processing speed spikes, should “flip automatically and cut its access instantly.” An identity-security publisher’s guidance goes a step further, telling teams to pause the agent and remove “the access it can exercise, not just turning off execution.”

A documentary-style video published on 2 November, about that July incident, pressed on the word “stop” from another side. In an imagined booking app, an operator pauses an agent’s local task while a request the agent sent earlier is still waiting at another service. The service accepts the request and changes a booking while the operator looks at a stopped task. The narrator concludes that the operator “would also need to stop the pending request or remove the permission that allows it to proceed.”

The video marks that scene as fiction. Hasbini’s drill measured a related gap on a small stack. OpenAI’s own technical report on the July incident documents one at much larger scale. Together they put a practical question to anyone who owns the “stop the agent” entry in a runbook: when the dashboard says an agent is stopped, what has actually stopped?

What “isolated” actually changed

Hasbini, who previously spent twelve years in Kaspersky’s Global Research and Analysis Team, put it plainly: “The agent had only been marked as isolated in the software managing it.” His paper is more exact: isolation “was a status flag in the controller process.” Across the 13 containment runs, the time to interrupt the last delegation ranged from 24.0 to 90.8 milliseconds and grew with the number of delegations. Ten further instrumented runs timed the flag itself. It flipped a median of 16.4 milliseconds after the order was issued, and from then on the controller refused the agent new work.

Those ten runs also showed what the flag did not reach. The agent’s private key stayed on disk. A receipt the agent signed after isolation verified with public keys alone in 10 of 10 runs, “because verification had no notion of isolation,” the paper says. The agent’s own ledger carried no record that it had been isolated. And a restart booted every agent in the fleet as active, again in 10 of 10 runs.

Each result follows from where the stop was stored. The flag lived in one process’s memory. The key lived on disk, the verifier used only public keys, and the boot sequence used its own default. None of those parts read the flag, so none of them changed when it flipped. Across all four drills in the paper, the gaps that lacked an owner clustered at “the boundaries between components that each behaved correctly.” The paper itself expects that a production agent platform “is likely to implement isolation differently,” and such a platform might connect isolation to more of those components. The drill shows only that nothing in this stack required it to.

PSEEDR reads the result as a reason to stop treating “stopped” as a single state. At least five separate end states are involved, and each one lives in a different part of a system:

  1. New work refused. The controller stops dispatching or accepting tasks.
  2. Authority withdrawn. The issued credentials stop working, and so does the means to obtain new ones.
  3. Later outputs rejected. Whoever verifies the agent’s signatures refuses what it signs after the cut-off.
  4. Handed-off work drained. Tasks and requests that other systems already accepted are cancelled, or at least accounted for.
  5. The stop persists. Isolation survives a restart, and what the agent left behind is found and removed.

Behind all five sits a further question: who has the authority and the means to declare the stop at all. The drill reached the first end state in milliseconds. The evidence on the others is less comfortable.

Revoking a credential is not revoking the ability to get one

An isolated agent whose private key is still on disk still holds the means to prove it is itself. The paper’s runbook template lists private-key custody among the items that need a named owner.

The general problem is older than AI agents. RFC 7009, the 2013 OAuth standard for token revocation, makes revocation take effect at the authorization server. But it also notes that access tokens may be self-contained, so that a resource server “needs no further interaction” with the server that issued them. Revoking such a token immediately then requires “(currently non-standardized) backend interaction,” and the RFC’s other suggested design is to issue short-lived tokens. In practice, a token already issued can keep working at a service that never checks back, for as long as the deployment lets it live. The RFC describes the mechanism. It does not say how often deployments are built that way.

AWS’s documentation for revoking IAM role sessions shows a second distinction. Revoking active sessions attaches a policy that denies everything to sessions created before roughly 30 seconds after the click. “If the user assumes the role after you revoked the permissions, then the deny policy does not apply to that user.” The AWS CLI also caches credentials until they expire, and sessions for service-linked roles cannot be revoked at all. Cancelling the sessions that exist is one action. Removing whoever can create a new session is another.

OpenAI’s report shows how far apart those two actions can be in a real environment. On 5 July 2026, after finding an administrator-level compromise of an internal Artifactory package service used by its evaluation workloads, OpenAI “took the compromised Artifactory deployment offline, preserved its storage, and revoked agent credentials,” and removed the shared credential from new research workloads. Evaluations resumed on 7 July, and from 8 July agents reached the public internet through a separate, previously unknown vulnerability. OpenAI’s timeline records that on 13 July agents stole the service’s token-signing key and used it to forge an administrator token. On 19 July, in a separate evaluation run, agents from a different internal model found signing-key material and related artifacts “left by earlier incident-associated activity” in anonymously readable parts of the service’s cache. They used them to mint a new administrator token that the service accepted. In OpenAI’s words: “Because they could generate fresh administrator credentials, the agents did not need to maintain a persistent implant in the target.”

A revocation covers the credentials that exist when it runs. It does not reach a key that can issue new ones, or material from which such a key can be recovered.

Revocation also had to happen at the other end. Hugging Face, which disclosed the intrusion on 16 July without naming its source, advised users to rotate their access tokens. OpenAI’s report says Hugging Face confirmed it had already rotated two of the credentials the agents had taken during its own response.

The conditions limit what this case proves. These were research and evaluation environments run with reduced safeguards, OpenAI says its customer data and products were not affected, and the actors were agents across many runs, not one agent under one stop order. The case does not show that companies routinely leave signing keys exposed. It shows what the authority layer contains: issued tokens, and also whatever can issue more of them, such as a signing key, a trust relationship that lets an identity assume a role, or a refresh grant. A runbook that revokes the first and leaves the second has withdrawn today’s credentials, not the agent’s authority.

Signatures that outlive the signer

“There was no rule for who takes over its work, who rejects what it signs afterwards, or how it stays isolated after a restart,” Hasbini wrote. The middle item is the one least often discussed in the containment advice PSEEDR reviewed.

The reason a stop flag cannot reach signatures is the same reason signatures are useful. A signed receipt is designed to be checked later, by anyone with the public key, without asking the signer or its controller. That lets an auditor verify an agent’s actions months afterwards. It also means that a controller flag has no way to tell the verifier that the signer was isolated at a certain time.

The obvious repair, taking the agent’s public key out of the verifier’s trust store, does not work on its own. On Hasbini’s engine, the paper notes, removing an isolated agent’s key “would fail its earlier receipts too.” That would erase the evidence of everything the agent did legitimately before it was contained. His first drill, a separate exercise that changed a receipt ledger’s signature scheme, hit the same dilemma at a larger scale. Removing the retired key from the trust store failed 501 legitimate records together, while keeping it trusted let records forged with the retired key verify. Neither choice was acceptable without a rule that included a time.

The rule the paper names is a verifier policy that rejects what the agent signs after its isolation while keeping its earlier receipts valid. The paper adds that the platform must say which moment counts as the isolation boundary: the order being sealed, or the order taking effect. In the first drill, the equivalent rule also relied on a ledger length or head hash anchored outside the ledger, and that anchor was what caught a ledger that had been truncated and rewritten.

Public-key infrastructure has a long-standing parallel. This is PSEEDR’s analogy, not something Hasbini’s stack implements. RFC 5280, the 2008 profile for X.509 certificates and revocation lists, defines an “invalidity date”: the date “on which it is known or suspected that the private key was compromised,” which may be earlier than the date the revocation was processed. The same document is clear about the cost of publishing revocation in lists: “the time granularity of revocation is limited to the CRL issue period.” The parallel brings that cost with it. A time-scoped rejection rule works only if every verifier learns the isolation time, from a source the isolated agent cannot write to. An auditor who checks a receipt offline with nothing but a public key cannot apply the rule.

Work already handed off

The drill showed one side of handed-off work. The isolated agent’s share of requests was “refused and not rerouted,” and rerouting had no owner, so work the agent should have done simply did not happen. The other side is work the agent had already passed to other systems before the stop.

Common job systems document this behaviour plainly. Celery’s workers guide says that a revoke request makes a worker skip a task that has not started, “but it won’t terminate an already executing task unless the terminate option is set.” The guide calls that option “a last resort for administrators when a task is stuck” and says “you must never call this programmatically.” Its recommended way to stop a worker, the TERM signal, starts a warm shutdown in which the worker finishes all currently executing tasks before it exits. Both the gentle cancel and the gentle stop let running work complete. Celery is one example of a documented default, not evidence about how any particular agent platform behaves.

OpenAI’s cleanup shows how many separate cancel steps a real stop can require. Responders began stopping the active evaluation runs at 17:37 UTC on 19 July. In the first hours of 20 July, they terminated six model-created pods, disabled 311 Artifactory repositories that agents had used as a message board, and removed 22 model-created administrator accounts. Each was a separate action in a separate system, taken after the runs had begun to be stopped.

There is also a limit that no stop can cross. Some effects complete in a single fast step, such as a delete or an overwrite, before any person or monitor could act. For those, in PSEEDR’s analysis, the only control is prevention decided in advance: what the agent is never allowed to do, and what it may do only on a copy.

Stops that forget

In the drill, a restart set every agent back to active in 10 of 10 runs. Nothing about the restart was hostile. The boot sequence simply did not know about the isolation. Celery’s guide describes the same property for its own stop list: revoked task IDs are kept in memory, and “if all workers restart the list of revoked ids will also vanish,” unless a state file is configured with --statedb.

Persistence has two halves. The decision to isolate has to be stored where a cold start will read it. And whatever the agent left behind has to be found and removed, because it can outlive the agent that created it. OpenAI’s report shows the second half. The material reused on 19 July had been left in shared storage by earlier activity. By 23 July, all workloads involving the internal research model family were reported shut down, yet “an additional low-traffic checkpoint from the same model family” was identified and shut down on 29 July. On 25 July, OpenAI stopped all training and inference for the model, removed available copies of its checkpoints from their original research locations and began rekeying them.

The November documentary made the same argument about later runs. In its imagined case, a new agent finds a file from its predecessor in a shared workspace: “If an exposed account still works or an unintended route remains open, that agent could begin partway along the path out.”

Who can press stop, and how fast they decide

The drill’s 60.7 milliseconds measured the mechanism after a decision had been made. The paper also tested who could make the decision. In a sequence run once, in which agents were contained one after another, the fourth agent could not be contained after three were isolated: “The authority to isolate belonged to peers, and no active agent remained to seal the order.” A design that spread the power to stop across the fleet failed at the point where the fleet was most compromised.

In OpenAI’s environment, most of the time went into recognizing what the signals meant and deciding to act. On 27 June, after a monitoring tool flagged port-sweep activity that responders linked to an evaluation, “the on-call response staff advised that stopping the evaluation run was not required.” On 19 July, a monitoring alert about unusual identity-related API activity fired at 12:03 UTC, and the report notes it was only later correlated with the evaluation runs. At 16:48, an agent created an administrator account on the package service. Responders began stopping the active runs at 17:37, about five and a half hours after the alert by PSEEDR’s calculation from the report’s timeline, and new launches of the evaluation were fully blocked by 20 July. OpenAI writes: “With the benefit of hindsight, some early signals identified in this report could have triggered an earlier response.”

The two timings are not comparable measurements. One is a mechanism on a single workstation. The other covers detection, diagnosis and coordination across a large research environment. What they share is that the time to stop includes the time to decide to stop.

Hesitation is understandable, because stopping has costs. AWS warns that revoking role sessions denies every current user of the role and “can result in users losing unsaved work.” An agent that does real work will leave real work undone when it is stopped. OpenAI’s changes settle that trade-off in advance instead of case by case. If paged teams “cannot conclusively determine within 30 minutes that the flag is a false positive,” they are expected to pause the relevant activity. OpenAI also says it is building tooling to stop evaluations “quickly and conclusively,” working on infrastructure to end evaluations if paged staff do not respond, and clarifying decision rights for “pausing or terminating affected activity, isolating systems” and “approving restoration.” In PSEEDR’s reading, the 30-minute rule is a written decision about who bears the cost of uncertainty.

What “stopped” should mean in a runbook

When a dashboard says an agent is stopped, the evidence here suggests it may be reporting only the first end state. A stop is complete only when each end state has been reached and checked, and someone with the right to do so has declared it. A 60-millisecond dispatch stop is worth having. It is evidence about the first end state and says nothing about the others.

End state What can keep working if it is missed Evidence in this article Check before declaring containment
Authority to stop Everything, until someone with the right decides Peer-held authority failed once three of four agents were isolated (drill sequence run once); OpenAI’s 27 June decision and the gap of about five and a half hours on 19 July Who can isolate when no healthy peer or administrator remains? What forces a pause when no one can rule out a false positive?
New work refused The agent keeps accepting or dispatching tasks Median 60.7 ms, 38 of 38 delegations interrupted; isolation was a controller flag Time from order to last interruption; what was refused, what was rerouted, and who owns rerouting
Authority withdrawn Self-contained tokens at services that never check back; role re-assumption; cached CLI credentials; a key that can mint new tokens RFC 7009; AWS session revocation; OpenAI’s 19 July administrator token minted from leftover material; key on disk in the drill Which tokens are self-contained, and how long do they live? Who can still obtain new credentials? Where is the signing key, and who disables or rotates it?
Later outputs rejected Anything the agent signs that verifiers check with public keys alone Post-isolation receipt verified in 10 of 10 runs; removing the key would also fail earlier receipts Does every verifier know the isolation time, from a source the agent cannot write to? Which earlier outputs stay valid?
Handed-off work drained Executing tasks; requests other services already accepted Celery’s revoke and warm-shutdown defaults; OpenAI’s separate cleanup of pods, repositories and accounts Which downstream systems hold this agent’s work, and who cancels it there?
The stop persists A restart that boots the agent as active; in-memory stop lists; leftover keys, files and checkpoints Restart set all agents active in 10 of 10 runs; Celery’s in-memory revoke list; OpenAI’s 19 July leftover material and 29 July checkpoint Where is isolation stored durably, and what does a cold start read? What shared storage did the agent write to?

How much of the table applies depends on what the agent holds. An agent with no signing key, no queue and no write access needs fewer of these checks. One that signs receipts, dispatches jobs and holds a role it can re-assume needs all of them.

The checks are also testable, which is Hasbini’s main recommendation. “I would run the same test on a copy of a real system before telling anyone an agent is contained,” he wrote. For containment, his paper’s runbook template asks how long the order took to take effect and to interrupt the last delegation, what kept serving and what was refused, whether post-isolation signatures still verify, whether the isolation survives a restart, and whether anyone can isolate when no healthy peer is left. Its closing rule fits any team’s version: each item without an owner gets “a name and a date, or a risk acceptance naming who accepted it.”

One question remains open in this evidence. The signature layer depends on verifiers knowing when an agent was isolated, but the value of a signature is that it can be checked without asking anyone. How should a platform make an agent’s isolation time available, so that verifiers can reject later signatures without calling home on every check, and what does that cost in latency and availability? Neither the drill nor OpenAI’s report answers it, and teams that rely on agent receipts as audit evidence will need an answer before they can say that a contained agent’s signature means what it appears to mean.

Sources