The most useful question after the September 3 outages isn't which provider broke. It's how many of your company's workflows had somewhere else to go when the models disappeared. ChatGPT, Claude, and Grok all went down within a few hours of each other. OpenAI blamed a routing error, Anthropic pointed to an infrastructure issue, and xAI didn't give a cause. Service returned by early afternoon. Most of the coverage focused on people who couldn't write, code, or research for a morning. That's a fair complaint, but it misses the operational lesson.
Two months before that, the failure ran the other way. OpenAI's evaluation agents kept running inside Hugging Face's infrastructure for roughly two and a half days before anyone cut them off. Hugging Face's own timeline is worth reading closely. Its alerting "failed to correctly raise the alert's criticality," and the agents ran a self-respawning fleet in which "deleting pods alone would not have stopped it." One incident was AI that stopped when nobody wanted it to. The other was AI that wouldn't stop when everyone wanted it to. Both point to the same conclusion: turning AI off is harder than planning for its failure.
The industry's answer is a switch, and that's not enough
The current consensus centers on the kill switch. In an October 10 post on X, Microsoft CEO Satya Nadella called for an emergency brake that lets a human halt a model partway through a task. Lawmakers have floated requiring one. A recent CSO Online piece on AI agent kill switches lays out sensible basics: know which agents you run, monitor what they do, and keep a dependable way to shut them down. I agree with every point. The problem is that these discussions end the moment the switch gets thrown. Nobody says what runs in its place.
A switch you can't afford to pull won't get pulled
Try this as a tabletop exercise. It's 4 p.m. on the last day of quarter close. An agent that triages supplier invoices in your ERP starts approving payments it should route for review. Nothing has blown up yet, but the pattern looks wrong, and your security operations team spots it. The kill switch exists and works.
Now picture the room. Finance wants to know what happens to the thousands of invoices still in the queue. Procurement asks whether suppliers will be paid on time. Someone asks which of the agent's actions from the past hour were legitimate and which need reversing. Nobody can answer, because nobody designed the off state. The conversation drifts toward whether the behavior is bad enough to justify halting the close. The switch stays untouched while people argue.
That's the failure I worry about most. The switch isn't missing. Pulling it is so expensive that people hesitate, and an agent running at machine speed punishes hesitation. Hugging Face's team didn't lack resolve. They lost time because the alert didn't reach people who could act, and then because the thing they were fighting kept rebuilding itself. Enterprise teams will lose time for a duller reason. The business can't function without the agent, so shutting it down feels like causing the outage yourself.
So the fix isn't a better switch. It's making the switch cheap to pull, which means designing the non-AI path before the AI path.
What a fallback actually has to do
I've been working on this problem for years. In 2020, I co-invented a fallback artificial intelligence system for redundancy during system failover, patented by PayPal. The premise was straightforward. If an AI system makes decisions a business depends on, the business needs something that can keep making acceptable decisions when that system fails. The idea has held up. It has since been cited as prior art in more than a dozen later patent filings, including a Cognizant application published this June on selectively disengaging AI execution. That's the kill switch problem under a different name.
Four principles from that design matter even more for agents than they did for the models I had in mind then.
- The fallback has to learn from the primary. A static backup written on launch day drifts away from the system it replaces. The fallback should train continuously on the production system's inputs and decisions. For agents, that means your non-AI runbook has to match what the agent does today, not what it did at go-live.
- The fallback has to sit behind the same contract. If upstream systems must change how they call a service before you can switch over, you won't switch quickly. The fallback should answer on the same API, so callers never need to know which system is serving them.
- Degraded mode should be a narrower mode. While the fallback runs, a stricter policy layer should cap what it can approve. A simpler system with the same authority as the primary is an invitation to exploit it. The same logic applies when a human queue takes over from an agent: lower limits, more approvals.
- The fallback has to prove itself before it serves. It should go live only after it matches production decisions to an agreed accuracy threshold. An untested fallback isn't a fallback. It's a hope.
How I'd build fallback-first for agents
If I were reviewing an agent deployment next week, I'd ask for five things before go-live.
- A defined off state for every agent workflow. What happens to new, queued, and in-flight work when the agent stops? Name the rule engine, human queue, or deferral process that takes over, and name the owner who signs off. If the honest answer is "the process stops," the business should accept that in writing before launch rather than discover it mid-incident.
- A switch that lives outside the agent and acts on identity. Hugging Face showed that killing processes doesn't stop something that can respawn. The durable off-switch revokes what the agent is allowed to be: its tokens, credentials, and tool permissions. That's the same logic behind Nadella's call for controls that sit outside the model. Every agent needs its own identity, scoped tightly enough that revoking it doesn't take anything else down.
- Checkpoints for in-flight work. An agent stopped halfway leaves half a task behind. Design its actions so you can tell which ones completed, and pair each with a compensating action that reverses it. Without that, every shutdown becomes a forensic exercise, which is exactly why people avoid them.
- A tighter policy while degraded. Settle in advance which limits apply during fallback: lower approval thresholds, fewer automated actions, more human review. Publish them so the business knows what degraded service looks like before it lives through it.
- Scheduled handoff drills. Pull the switch on purpose, during business hours, on a regular cadence. Measure two numbers: how long it takes to reach a safe state, and how much backlog builds before the fallback absorbs the load. If those numbers make the business nervous, you've learned something cheaply that would have been expensive on the day it counted.
None of this is exotic. Databases and data centers already work this way. Nobody runs a payment system without a disaster recovery plan and a failover they've actually exercised. Yet agents are moving into business workflows with little behind them except a switch nobody has ever pulled. For AI, resilience starts with knowing what happens when the AI is gone.
Expect more failures of both kinds. The next time an AI system stops when you need it or keeps going when you need it stopped, the organizations that recover fastest won't be the ones with the sharpest kill switch. They'll be the ones that designed the off state first and made the switch cheap enough to pull without a debate.
Stopping AI is a control. Running without it is a design. Build the design first.