What a kill switch has to decide before anyone presses it
"We have a kill switch" sounds like an answer until someone asks what it actually has to stop, how fast, and what it leaves behind when it fires. For software that only acts on a human's say, a kill switch is almost redundant — nobody types the next command once a person decides to stop. For an autonomous agent already mid-task, "stop" is a design question with more than one right answer, and most of the engineering that makes a kill switch meaningful happens long before anyone ever reaches for it.
A command already issued isn't a command you can take back
By the time anyone notices an agent doing something it shouldn't, that agent likely already issued a shell command, opened a connection, or sent a tool call of its own choosing — it didn't pause mid-sentence waiting for a person to glance at a dashboard. A switch that only prevents the agent's next decision, without reaching the action already in flight, isn't stopping anything; it's a setting that takes effect eventually. The real design question is where in the execution path the switch actually sits: at the same point every other call already gets checked, or somewhere downstream of it that the agent has already passed.
A kill switch that only prevents the next decision an agent would have made isn't stopping anything in motion. It's a setting that takes effect eventually.
Suspending access only means something if nothing standing is left to use
Revoking an agent in an admin panel reads like the end of the problem, but it only is one if the agent has nothing else left to act with. An agent holding a long-lived credential it was handed once can keep using that credential after its entry in some dashboard goes grey — the revocation and the agent's actual ability to act are two different systems that have to agree before "revoked" is true. That's also why MCP's own guidance insists there should always be a human in the loop with the ability to deny a tool invocation: a deny has to land on the call itself, not on a record describing the agent that's supposed to govern it later.
What's left behind after it fires is part of the design, not an afterthought
Firing the switch mid-task leaves a system in some state, and which state depends on choices made long before anyone needed to stop anything. A pause that just halts execution wherever it happens to be can leave work half-committed: a write with no confirmation, a resource claimed and never released. A meaningful kill switch has to decide in advance whether stopping an agent means a reversible pause, where the agent's context stays intact and someone picks it back up later, or a hard revoke, where the identity is gone and nothing about that run gets trusted again. Treating "stop" as one undifferentiated action instead of two different guarantees is how a kill switch ends up looking fine in a demo and useless in the one incident it existed for.
It has to live where every other decision about the agent already does
None of this works bolted on after the fact, as a separate control racing whatever the agent is doing. Access decisions are supposed to default to exclusion, not permission, and a kill switch that lives outside the path where every call already gets checked is a second system that has to stay in sync with the first — one more place for a revoke to be true on one side and stale on the other. The switch has to sit at the same trust boundary every call already passes through, not next to it, so there's no window where an agent is mid-action with nothing yet in place to check it.
A button is the part anyone can see
What makes a kill switch work happened earlier: whether every call was already being checked somewhere an agent couldn't route around, whether a credential was ever standing long enough to survive a revoke, and whether "stopped" was defined as a pause or a revoke before the day it mattered. The button is just where a person expresses a decision the system was already built to carry out. Build a system that only ever knows how to pause, and the button labeled "revoke" was never really there.
Sources
- Tools. Model Context Protocol specification, version 2026-07-28. States there should always be a human in the loop with the ability to deny tool invocations — the deny has to land on the call itself, not just on a record describing the agent.
- Basic Principles of Information Protection. Jerome Saltzer and Michael Schroeder, Proceedings of the IEEE, 1975. The fail-safe defaults principle: base access decisions on permission rather than exclusion, so the default is lack of access — the same discipline a kill switch has to sit inside, not beside.
Frequently asked questions
What's the difference between pausing and revoking an AI agent?
A pause is reversible: the agent's context and state stay intact so it can resume later. A revoke is not: the agent's identity and access are gone, and nothing about that run is trusted again. A kill switch that doesn't decide which one it does before an incident isn't finished.
Why isn't suspending an agent's access in an admin panel enough to stop it?
Because revocation only works if nothing the agent already holds survives it. An agent sitting on a long-lived credential it was handed earlier can keep using that credential after its entry in a dashboard goes grey, unless the access check and the credential itself are the same system.
Where does a kill switch need to sit in an agent's execution path?
At the same trust boundary every other call already gets checked against policy, not as a separate control bolted on afterward. A switch living outside that path is a second system that has to stay in sync with the first, which is exactly where a revoke can be true on one side and stale on the other.
Zino can suspend or revoke any agent's access in seconds — a reversible pause or a hard revoke, enforced at the same in-process trust boundary where every REST, Shell, and MCP call is already authorized before it leaves, with no deploy to wait on.
See how Zino's kill switch works →