Skip to content
be-human.ai
← Back to the journal

Human oversight

Kill Switches for Business Agents: Stop Controls That Work

A business agent kill switch should halt actions at once while keeping memory intact, open tasks visible and logs complete. Here is how to design one.

Be Human typographic cover with the title: Kill Switches for Business Agents: Stop Controls That Work
Conceptual illustration created with AI · Be Human

A kill switch for a business agent, including the superintelligent agents now under discussion, is a control that stops its actions at once, suspends its access to tools, and holds its memory and queued work in a known state. Done well, it separates three jobs that are often mixed together: stopping new actions, freezing the agent's records, and deciding what happens to work already in progress. The rest of this article shows how to design those three jobs separately so that a stop protects the business without erasing the evidence or the context it needs.

Key takeaways

  • A kill switch should stop actions within seconds, but it should never wipe memory, delete logs or silently cancel open work.
  • Build three layers: halt new actions, suspend tool permissions at the enforcing system, and freeze state for review.
  • Every open task needs a defined end state: paused, handed to a person, completed, or cancelled with a recorded reason.
  • Test the switch on a schedule against a non-production copy, so you learn its behavior before an incident forces the question.
  • Name who may trigger each layer, who may resume the agent, and who decides what happens to queued work.

What a kill switch has to do

A stop control is only useful if it works while the agent is busy, confused, or acting on a request that should never have been accepted. Three requirements follow from that. It must take effect quickly, without waiting for the agent to finish its current reasoning loop. It must be reachable by more than one person and by a process that does not depend on the agent's own cooperation. And it must leave the system in a state a person can understand, because the question after every stop is what the agent did, and what is still pending.

What the switch should not do matters as much. A control that deletes memory to prevent further harm destroys the evidence needed to explain the incident, and it may remove context the business needs to serve customers correctly. A control that kills a process in the middle of a write can leave a record half updated, which is often harder to find than a visible error. The stop is a boundary placed around the agent's activity. It is not a reset of the agent's knowledge.

Separate the stop into three layers

Most weak designs bundle everything under one button labeled stop. Splitting the response into layers lets the operator choose the smallest action that solves the problem, and it makes each layer testable on its own. The full page of guidance on superintelligent agent kill switches covers the same separation from the incident side.

  • Layer one: halt new actions. The agent accepts no new triggers and starts no new tool calls. Any action already running is allowed to reach a defined checkpoint.
  • Layer two: suspend permissions. Tokens, API keys and connector grants are disabled at the system that enforces access, such as the gateway or the provider console, so a stuck process cannot act even if it keeps running.
  • Layer three: freeze state. Memory, prompts, the task queue and logs are preserved in read-only form, with the snapshot time recorded.

Layer two is the one most often skipped, and it deserves the most attention. An application can ignore a flag in its own code, but it cannot use a credential that the access system has revoked. OWASP's authorization guidance makes the general point that access decisions belong at the resource being protected, not only in the code that asks for it.

Build the stop path step by step

The following sequence is a practical starting plan. It assumes the agent already has a defined role, a list of tools, and an owner. If any of those are missing, define them first.

  • Step 1: Write the trigger conditions. Name the events that justify a stop, such as an action the agent was not authorized to take, data sent to the wrong recipient, a vendor incident, or repeated failures on a sensitive task. Keep the list short enough that people can remember it under pressure.
  • Step 2: Assign who can trigger each layer. Usually an operations lead and a named backup can halt actions at any hour. Decide in advance whether automated monitors may trigger layer one on their own, and whether only a person may trigger layer two.
  • Step 3: Route every tool call through one control point. If the agent reaches tools directly, a stop has to reach each path separately, and a missed path becomes the failure.
  • Step 4: Define a safe checkpoint for each task type. For example, a record may be allowed to finish writing, but an outbound message should not be sent after the stop.
  • Step 5: Assign each open item an end state. Paused, handed to a person, completed, or cancelled with a reason. Nothing is cancelled silently.
  • Step 6: Preserve before resuming. Snapshot memory and logs, record the snapshot time, and keep the snapshot unchanged while the review runs.
  • Step 7: Set resume rules. Resume only after the cause is written down, a named person other than the one who stopped the agent approves the restored access for high-stakes tools, and a harmless test task completes correctly.
A stop that cannot be explained afterward has only moved the problem from the agent to the people reviewing it.

Protect memory and open tasks during a stop

Agent memory is usually a mixture of stored notes, retrieved documents and conversation summaries. The risk during a stop is that a write already in progress leaves a partial note that later looks authoritative. Where your platform allows it, make memory writes complete or fail as a unit. Mark any entries written in the few minutes before the stop for review instead of trusting them automatically when the agent resumes. Retrieval of company documents should also be checked, because a reindexing job running during a stop can change what the agent sees on restart.

Open tasks need the same discipline. Repeating a request after a restart must not create a second effect. Payment APIs handle this with idempotency keys, where the same key returns the original result rather than repeating the action. Stripe documents this pattern for its API, and the principle applies to any agent that sends messages, creates records or moves money through a tool. Long-running agents also benefit from keeping progress in durable artifacts, such as a task file or ticket state, so a new session can see what was done. Anthropic's engineering notes on long-running agents describe this approach, and it is the habit to copy when designing resume behavior.

Illustrative scenario: a billing assistant is preparing fourteen customer credit notes when a finance lead notices that one amount is wrong. Layer one halts new credits at the gateway and lets the credit in progress finish its write. The remaining notes are marked paused with the reason. Two were already queued in the external billing system, so the team cancels them there and records the cancellation. On resume, the assistant re-reads the paused items, skips the two cancelled ones, and requests approval on the amount rule before it continues. Nothing was deleted, and the log shows who stopped what and when. For the records side of this scenario, see how legal holds apply to agent logs, memory and prompts.

Test the switch before you need it

A kill switch that has never been used is a hypothesis. Schedule a drill against a non-production copy of the agent, and repeat it after any change to tools, permissions or memory design. A useful drill checks four things: the time from trigger to halted actions, the completeness of the memory and log snapshot, whether a call with the revoked credential actually fails, and whether the resume path works with a harmless task.

  • Confirm the trigger reaches the agent within the time your operations team has agreed to accept.
  • Confirm that a test write in progress reaches its checkpoint and does not leave a partial record.
  • Confirm that a revoked credential is refused by the enforcing system, not only by the agent.
  • Confirm that the resume approval is requested from the right person and that the decision is logged.

Record the results alongside your other agent evidence. Monitoring shows what the agent did after the stop, and the drill shows whether the stop itself held. The OpenTelemetry observability concepts are a useful reference for the traces, metrics and logs that let a reviewer reconstruct the sequence of events afterward.

Who holds the switch and how Be Human runs it

Who may stop an agent is a design decision, and it should be made before the agent receives broader access. Clarify the owner of each layer, the backup, and the limits on what automated monitors may do alone. The guidance on who can stop a superintelligent agent walks through those ownership questions in more detail.

Be Human's managed approach treats the stop as part of the agent's design from the first engagement, not as an add-on after launch. The first scope names the role, the memory and tools the agent may reach, the approval boundaries, and who may trigger each layer of the stop. Managed operations then cover monitoring of the halt path, permission reviews whenever a tool changes, scheduled drills, and incident response in which every open task receives a recorded end state. The work is delivered remotely, in English or Portuguese.

If you are unsure which of your current tasks would be safest to hand to an agent and easiest to stop, take the free Be Human AI diagnostic to find the first task worth handing to an agent.

Frequently asked questions

Should a kill switch delete the agent's memory? No. Deleting memory during a stop destroys the evidence needed to explain what happened and can remove context the business still needs. Freeze memory in a read-only snapshot with a recorded time, then decide separately whether any entries should be corrected or removed after review.

Who should be allowed to pull the switch? Name at least one operations owner and one backup who can trigger a halt at any hour. Automated monitors can be allowed to trigger the first layer, which only stops new actions, but restoring or revoking access in high-stakes systems should involve a person with the authority to decide.

How do we know the stop actually worked? Test it on a schedule against a non-production copy of the agent. Check that new actions stop within the time you agreed, that a revoked credential is refused by the system that enforces access, and that a harmless test task resumes correctly after approval.

Does a kill switch replace human approval for risky actions? No. The kill switch is an emergency boundary that halts activity when something goes wrong, while approval gates decide in advance which actions need a person before they happen. Both are needed, and the approval rules determine how often the emergency stop should ever be necessary.

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.

Less busywork. More room for you.

Bring us the work you wish you had time for.

Book a call to try a personalized AI agent free for 7 days ↗Or take the free AI diagnostic →