Who Can Stop a Superintelligent Agent? Oversight and Kill Switches
Named roles that can pause or revoke a company AI agent, and how a kill switch should work across channels, tools and memory, with a practical checklist.

Who can stop an AI agent? The accountable business owner, the operator who runs the agent day to day, and an incident contact who can act outside working hours should each be able to pause it without waiting for a developer. Each of them needs written authority over a defined set of stops: one channel, one tool, memory writes, or the whole agent. The kill switch is the mechanism, but these named roles decide who presses it, when, and what happens to the work already in progress.
Key takeaways
- Name at least three people who can pause an agent, and test that each one can do it without help from a developer.
- Build the stop in four layers: channel, tool, memory writes and the whole agent.
- A pause should stop new actions while keeping logs, memory state and queued work intact.
- Revoking access is a separate act from pausing, and it needs its own checklist and its own test.
- Run kill switch drills before an incident, and repeat them after every change to tools, channels or permissions.
Who should hold stop authority?
Stop authority belongs to people, never to the agent. An agent should not decide whether its own permissions get reduced, and its operating instructions should say so in plain words. The NIST AI Risk Management Framework treats clear roles and accountability as part of managing AI risk, and a kill switch is one of the most concrete places where that principle shows up. In most companies, five roles cover the ground:
- The accountable owner, usually the business owner or a department head, who can pause any agent in their area and decides when it may resume.
- The agent operator, the person who maintains the agent's instructions, tool list and memory, and who can pause it during normal work.
- The incident contact, a named person with a reachable phone number and a named backup, who can act outside working hours.
- The lead of each affected function, such as customer support or finance, who may pause only the channels or tools that touch their work.
- The managed operations provider, if one is under contract, who executes a stop on documented instructions and records the action.
Write each name, the stops that person may use, and the backup into one page. A role without a named person behind it is a hope, not a control. Review the page whenever someone changes team, leaves, or takes on a new agent.
What are the four layers a kill switch should reach?
A stop that only means "turn the agent off" is too blunt for most real situations. A better design works at four layers, and each layer answers a different question about risk.
- Channel: stop outbound messages on email, chat, text or voice while internal drafting continues. The question it answers is whether the agent can still reach customers or staff.
- Tool: suspend a specific integration, such as a payment, calendar, file or ticketing tool. The question is whether the agent can still change records.
- Memory: freeze writes to long-term memory, so that a faulty instruction or a wrong fact is not stored as a standing rule. The question is whether the agent can still learn from this.
- Whole agent: stop every action, including scheduled jobs, background runs and webhook handlers. The question is whether anything is still running.
Test each layer against its question during design. If the team cannot say, with a specific system name, how a channel pause works, that layer is not built yet. Layers also tell you the order to use: stopping the outbound channel usually limits harm faster than stopping the whole agent, because internal work can keep running for investigation.
What must a pause preserve?
A pause that deletes evidence creates a second problem. Before any stop, the agent's actions, tool calls and decisions should already be recorded in a form people can read later. The OpenTelemetry observability primer describes logs, traces and metrics as separate signals that together show what a system did and why. For an agent, that means each step, each tool call and each memory write should leave a timestamped record tied to a run identifier, so an investigator can reconstruct a single conversation or task.
A pause must keep three things intact. Logs must stay readable and retained under your own policy, not only inside the vendor's dashboard. Queued work, such as messages waiting to send or approvals waiting for a person, must be held rather than dropped or silently retried when the agent resumes. Memory state must be frozen so the review can see what the agent believed at the time of the stop. For the mechanics of halting actions while keeping that evidence, see how to halt agent actions without losing logs or queued work.
Illustrative scenario: a refund reply goes wrong
Illustrative scenario, not a real case: a customer-facing agent begins answering refund questions with a policy that was edited in a draft document but never approved. The support lead notices the problem on a Friday afternoon, and the team follows its written plan.
- The support lead pauses the customer messaging channel first. Internal drafting continues, and unsent replies stay in the queue.
- The operator suspends the refund lookup tool, so the agent can no longer quote amounts from the billing system.
- Memory writes are frozen, so the unapproved policy text is not stored as a standing rule.
- The owner reviews the run logs, lists the affected conversations, and decides which customers need a human reply that day.
- Only after the policy is corrected and a sample of test conversations has been reviewed does the owner lift the pauses, one layer at a time.
The value of this sequence is that no one needed to guess. Each person knew which layer was theirs, what to preserve, and who would decide the restart.
Revoking access is a separate step
Pausing stops the agent for now. Revocation removes what the agent could use later, and the two actions should never be confused in a runbook. A pause can be lifted in minutes. Revocation should be treated like offboarding: deliberate, recorded and checked.
A revocation checklist usually covers API keys and OAuth grants tied to the agent's identity, service accounts, messaging channel registrations, webhook endpoints, shared folder permissions, and any credentials stored in configuration files or prompts. The OWASP authorization guidance stresses least privilege and enforcing authorization on each request, which is why a revoked grant should fail at the provider, not only disappear from an internal list. After revoking, attempt one call with the old credential, confirm it is refused, and write down the result. For a practical sequence, see the checklist for revoking agent access to tokens, keys and channels.
How Be Human handles this
Be Human's managed approach treats stop authority as part of the first engagement rather than an add-on. The engagement names the accountable role for each agent, maps its channels, tools, memory and permissions, and writes the stop layers in advance. The success criterion for the agent includes a pause that has been tested, not only described. Managed operations then keep the control current through scheduled permission reviews, monitoring of run logs, kill switch drills after integration changes, and incident response that follows the roles already written down. The agent's identity and memory stay under human control, and the people named in the plan keep the authority to change them.
If you are not sure which task should be the first one to hand to an agent, the free Be Human AI diagnostic can help you find it.
Frequently asked questions
Can the agent stop itself if it detects a problem? It can be instructed to raise an alert and stop taking new actions, and that behavior is useful. It should not hold the authority to reduce its own permissions or to decide that a stop is unnecessary, because stop authority has to sit with named people and with controls outside the agent.
Does pausing an agent delete its memory? It should not. A pause freezes memory writes and preserves the stored state so the team can inspect it, while deletion is a separate and deliberate action that follows your retention and deletion policy and is recorded when it happens.
How often should a kill switch be tested? Test it after every change to tools, channels or permissions, and also on a regular schedule that the owner sets. Each drill should confirm that every named role can execute each stop, and that the expected logs and held queue appear afterward. Keep the result so the next review can compare against it.
Who is responsible when a paused agent has already caused harm? The pause limits further harm, but it does not settle responsibility. Accountability depends on the contracts, approvals and policies in place before the incident, which is why roles and records should be written first. For that question, read who is accountable when an AI agent makes a mistake.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


