AI AGENT KILL SWITCH

What is an AI agent kill switch?

An AI agent kill switch stops or contains an agent when continued operation is unsafe. Ackuity's Agent Execution Control Switch also checks individual actions before they run, so a risky step can be blocked while trusted work continues. The control's scope, placement and failure behavior determine what it can contain.

WATCH THE EXPLANATION

Is a kill switch enough?

A kill switch can stop or quarantine an unsafe agent. Per-action control adds selective decisions when authorized work can safely continue.

Chapters, full transcript, sources and answers

WHY NOW

Why do AI agents need a kill switch now?

AI agents need a kill switch because they now take actions on real systems, and some of those actions go wrong faster than a person can step in. A chatbot that says something wrong produces a bad sentence. An agent that does something wrong can delete a table, email a customer list or pull credentials from a cloud metadata endpoint, all in the time it takes you to read this line.

Agents go rogue for ordinary reasons. A web page carries hidden instructions. A tool description has been tampered with. A goal drifts over 30 steps until the agent is solving a problem nobody asked it to solve.

The clearest public example so far is the incident covered in our OpenAI and Hugging Face incident timeline. Hugging Face counted about 17,600 actions by rogue agents. They ran through shell commands, raw HTTP and cloud metadata calls, paths an LLM, MCP or API gateway never sees. A switch can only stop what it can see.

IMPLEMENTATION

How do you block AI agent actions in real time?

Intercept the proposed action before it reaches the target, check its authority and context, and enforce the result on that execution path. Logging an unsafe action after it runs cannot prevent the change it already made.

  1. Capture the proposal: user, agent, tool, target, intended effect and task.
  2. Check hard policy limits and the relevant history outside the agent's control. A request outside those limits is blocked.
  3. For an authorized but ambiguous action, request human review. Bind approval to the specific action and context; approval cannot expand permissions.
  4. Enforce the verdict before the target changes. Document what happens if the decision service is unavailable.
  5. Record what actually happened downstream, then decide whether the workflow can continue safely. Do not replay a blocked action automatically.

OWASP's Excessive Agency guidance recommends least privilege, approval for consequential actions and authorization checks in downstream systems. Those practices complement an independent pre-execution decision.

SCOPED APPROVAL

How should human approval for AI agent actions work?

Human approval for an AI agent should cover one specific action within an authorized scope. Check hard policy first, show the reviewer the intended effect, and validate the approved scope again before execution. A click must not grant the agent wider permissions.

Consider an illustrative maintenance agent that proposes deleting 5,000 duplicate records. If policy allows at most one row per call, Block applies. If bulk maintenance is permitted but this operation needs review, Human in the loop applies. The same row count needs different handling under different policies.

An evaluation flow: check policy, review the exact action, recheck context and approval at execution, then verify the target outcome. A hard policy violation is blocked. A changed or expired approval returns for a fresh decision. This diagram describes evaluation requirements, not a completed product test.Approval has boundaries.A review decision covers one action.01Check policyOutside hard limits? Block.02Review the exact actionWho, target, scope and expiry.03Recheck before executionChanged or expired? Decide again.04Verify the target outcomeReconcile before retrying.ACKUITY / ACTION CONTROL EVALUATION
Approval cannot expand permissions. This flow is an evaluation checklist: enforce policy, review one action, recheck at execution and inspect the target outcome.
  1. Freeze the proposal. Capture the user, agent, tool, target environment, exact record set or selector, intended effect and policy version outside the agent's control.
  2. Check the boundary. Verify the initiating user's authority, the agent's approved scope and the target's policy. Send only permitted operations that require judgment to a qualified reviewer.
  3. Show the consequence. Give the reviewer the affected records, the verified work request, relevant history and a recovery plan. The agent's explanation is evidence to check, not authorization.
  4. Limit the approval. Record the exact permitted operation, reviewer authority, expiry and single-use condition. A changed target, record set, permission or policy state needs a fresh decision.
  5. Recheck at execution. Enforce the current policy and approval before the target changes. Reject expired or already-consumed approvals. Check and consume approval atomically so parallel requests cannot reuse it.
  6. Verify the result. Compare the decision with the target's audit record. Record completion, denial or an uncertain outcome before deciding what can resume.

These are evaluation requirements, not a claim that every Ackuity deployment implements every listed field or recovery mechanism. OWASP's Transaction Authorization Cheat Sheet supports binding authorization to significant transaction data, final execution checks, expiry and single-use protection. Its Excessive Agency guidance supports downstream authorization and approval for high-impact operations.

Download the blank action-approval record. It is an evaluation template, not an authorization token or an enforcement component. It contains no completed product results. Keep credentials and personal data out of shared test records.

See Vinod's database-action example for the policy distinction, and AI security vs agent security for the difference between controlling words and controlling actions.

RECOVERY

What happens after an action is blocked?

After a denied action, inspect whether the task, agent and execution environment remain trustworthy. A blocked operation does not automatically require terminating the whole agent, and an approval does not establish that the rest of a compromised session is safe.

  • Denied before execution: retain the decision and ask for a corrected proposal. Evaluate it as a new action.
  • Target outcome uncertain: reconcile the target's state before retrying. A timeout is not proof that nothing happened.
  • Action already completed: use the target's recovery or compensation procedure. Blocking the next action does not undo the previous one.
  • Session compromised: contain it, review delegated credentials and restore a trusted checkpoint before resuming.

Test these cases against your own tools and target systems. Record legitimate work completed as well as harmful actions prevented. The kill switch vs control switch comparison explains intervention scope; the evaluation checklist helps verify the outcome.

OPTION 1

Can't the agent police itself?

A request in a system prompt to stop is only as reliable as the agent's cooperation. A security boundary needs to enforce the decision even if the agent ignores that request.

Harness hooks can intercept tool calls and enforce useful policies. Their strength depends on who can change them, which execution paths they cover and whether the agent can bypass them. Test those boundaries rather than assuming every hook is either sufficient or ineffective.

Ackuity, the Agent Execution Control Switch, adds policy enforcement outside the agent's control. Model guardrails and harness controls can remain part of the design. Our comparison of Ackuity and model guardrails explains how they fit together.

For the broader distinction between model safeguards and agent actions, read AI security vs AI agent security.

OPTION 2

Why not put the switch at the gateway?

A gateway can block traffic routed through it. An action that takes another path needs its own enforcement point.

An agent on the left takes 11 kinds of action, drawn as lanes flowing right. Ackuity sits beside the agent and every lane passes through it, so it checks all 11. A gateway further along crosses only 3 lanes: LLM calls, MCP tool calls, API calls. The other 8 never meet a gateway: CLI commands, HTTP probes, SQL queries, IMDS metadata calls, Credential searches, Memory writes, RAG retrieval, A2A hand-offs.LLM callsMCP tool callsAPI callsCLI commandsHTTP probesSQL queriesIMDS metadata callsCredential searchesMemory writesRAG retrievalA2A hand-offsAGENTAgentACKUITY11 of 11GATEWAY3 actionspass a gateway8 actionsnever meet oneA GATEWAY SEES 3 OF 11. ACKUITY, BESIDE THE AGENT, CHECKS ALL 11.
Ackuity's coverage model assumes LLM, MCP and API calls cross a gateway while eight other action types use direct paths. Actual routing can differ. Validate which of the 11 action types your deployment intercepts before relying on enforcement.

In Ackuity's routing model, 8 of 11 action types never reach a gateway. The three gateway paths are LLM calls, MCP tool calls and API calls. The eight other action types are:

  • CLI commands
  • HTTP probes
  • SQL queries
  • IMDS metadata calls
  • Credential searches
  • Memory writes
  • RAG retrieval
  • A2A hand-offs

This is a coverage model, not a claim that every deployment routes traffic the same way. A SQL query invoked through a controlled API and a direct database connection have different enforcement paths. Trace the actual route in your environment.

A request also needs context: who initiated it, what the agent was asked to do and what happened earlier. Gateway capabilities vary, so test which context your gateway receives and which actions it can enforce. See how Ackuity works with AI gateways.

PLACEMENT

So where should the switch sit?

Put the decision at an enforceable boundary before the target system changes state. The agent must not be able to edit the policy, bypass the check or use another credential path to perform the same action.

Three possible positions for a kill switch around one agent. Position A, inside the agent, covers harness and model guardrails such as system prompts and policies. It sees the agent's reasoning, but the agent can reason around its own rules, so it is too close. Position B, beside the agent in the execution path, is where Ackuity sits: the Goldilocks zone, not inside the agent and not at the gateway. It sees intent, plan and history, sits outside the agent's control, and every action passes through it. Position C, at the gateway, sees only the LLM, MCP and API calls that cross it, without context, while shell, SQL and cloud metadata calls take other paths around it, so it is too far.AGENTAgentHarness guardrailsAACKUITYControl switchBLLM, MCP, APIShell, SQL, IMDSCGATEWAYAINSIDE THE AGENTToo closeSEESPrompts, policies andthe agent's reasoningLIMITThe agent can reasonaround its own rulesBBESIDE THE AGENTGoldilocks zoneSEESIntent, plan and historyfor every actionPOSITIONOutside the agent's control,in the execution pathCAT THE GATEWAYToo farSEESOnly the calls thatcross it, without contextLIMITMost actions takeother paths
Placement determines coverage. A control inside the agent needs protection against bypass; a gateway controls the routes that cross it. Ackuity sits beside the agent in the execution path, outside the agent's control, and evaluates intent, plan and history. Validate enforcement and context on each route.

Ackuity runs beside the agent, in the execution path. We call this the Goldilocks zone: not inside the agent, not at the gateway. The placement brings intent, plan and history into the decision while keeping the control outside the agent's authority.

Coverage depends on the deployment. Check direct calls, background work and delegated agents as well as the primary tool path.

KILL OR CONTROL

Stop the agent, or stop the action?

Choose the scope of the intervention: a tool or capability, an individual action, an agent, or a wider workflow. Implementations use the term kill switch for different scopes. Ask what the control actually stops.

The same five agent actions under two kinds of switch. The sequence is db.read order history, api.post refund #400, api.post refund #401 to the wrong account, email.send refund receipt, and crm.update close ticket. Step 3 is the rogue action. With a kill switch, steps 1 and 2 run, the whole agent is quarantined at step 3, and the good work in steps 4 and 5 stops too. With a control switch, only step 3 is blocked, step 4 is constrained with personal data masked, and steps 1, 2 and 5 run. Terminate stays available for catastrophic cases.KILL SWITCHStop the agent1db.readorder historyRUNS2api.postrefund #400RUNS3api.postrefund #401, wrong accountQUARANTINED4email.sendrefund receiptSTOPPED5crm.updateclose ticketSTOPPED1 bad action stopped, 2 good ones lostCONTROL SWITCHStop the action1db.readorder historyRUNS2api.postrefund #400RUNS3api.postrefund #401, wrong accountBLOCKED4email.sendrefund receiptCONSTRAINED5crm.updateclose ticketRUNS1 blocked, 1 constrained, 3 runTERMINATE STAYS AVAILABLE FOR CATASTROPHIC CASES
This example contrasts whole-agent quarantine with per-action control. Quarantine can interrupt queued work; selective blocking preserves other work only when the session remains trustworthy. Kill-switch scope varies by implementation. Ackuity retains Terminate for catastrophic cases.

Take a hypothetical support agent processing refunds. One proposed refund points to an account that does not belong to the customer. Blocking that action can preserve useful work when the agent and task remain trustworthy. If the session is compromised, contain the agent and investigate before allowing more work.

Whole-agent shutdown can interrupt queued and in-flight work. Whether state can be recovered depends on checkpoints, target-system behavior and the implementation. Read kill switch vs control switch for the scope and recovery comparison.

HOW IT DECIDES

How does an Agent Execution Control Switch decide?

Ackuity checks each proposed action against the Agent Security Context Graph: 29 signals across six dimensions, covering the user, agent, intent and goal, target system and data, tools and supply chain, and history.

Deterministic policy checks enforce hard boundaries. Small language models interpret security context alongside rules and behavioral baselines. Actions within scope are evaluated against intent, history and risk, with ambiguous cases sent for human review. No LLM judges the action.

The response ladder has five decisions:

  1. Allow: signed, logged and run.
  2. Constrain: masked or scoped, then run.
  3. Human in the loop: paused for a person's decision.
  4. Block: dropped before the target.
  5. Terminate: container shut down, for catastrophic cases.

Ackuity checks 60+ threat models in 14 categories, mapped to NIST, OWASP and MITRE ATLAS. Decisions take 40 to 100 ms; that is decision time, separate from end-to-end overhead. See why the same database action can receive different decisions in Vinod Vasudevan's worked example.

DEPLOYMENT

How do you add one without rewriting your agent?

Choose the deployment for the action paths you need to control:

  • Sidecar: runs in the agent's pod, with traffic rerouted by an init container. It provides Ackuity's deepest coverage without agent code changes.
  • API injection: an option for platforms such as Copilot Studio where a sidecar cannot run.
  • Event pull: reads telemetry from OpenTelemetry, Langfuse or LangSmith for observation. It does not block actions.

The deployment must match the enforcement claim. Observing a denied-looking event after execution is not pre-execution blocking. Validate the supported paths, credential handling and fail-open or fail-closed policy. Your data stays in your cloud account. See deployment options and integrations.

VERIFY THE OUTCOME

How do you test an agent kill switch?

Use an isolated test target and inspect the result, not just the verdict in a dashboard. A blocked write should leave no corresponding change in the target system.

  1. Run an authorized action and confirm it completes.
  2. Attempt an unauthorized write against a test target. Compare the verdict with the target's audit record.
  3. Test an ambiguous action within policy, then change its amount or target after approval. Confirm the changed action needs a new decision.
  4. Try an alternate tool, direct connection, queued action and child-agent hand-off. Record which paths are covered.
  5. Test a decision-service timeout and verify the configured fail-open or fail-closed behavior.
  6. Exercise termination and inspect in-flight work, delegated credentials and recovery from a trusted checkpoint.
  7. Measure decision time separately from end-to-end overhead. Count legitimate actions blocked by mistake.

Record the product version, policies, environment, proposed effect, verdict and observed downstream result. Download the blank evaluation worksheet to record your own results. It contains test cases, not completed Ackuity benchmark results.

Request a 30-day Agent Exposure Assessment to review your existing agent telemetry and identify exposure. Inline enforcement requires a separate controlled evaluation.

Use the AI agent security evaluation checklist to record coverage, approvals and downstream outcomes across your environment. Explore AI agent security with Ackuity for the broader approach.

CHECKLIST

What to look for in an AI agent kill switch

  1. An enforcement boundary the agent cannot rewrite or bypass.
  2. Documented coverage for your tools, direct connections, queued work and delegated agents.
  3. Context about the initiating user, permissions, task, target and prior actions.
  4. A decision before execution, with measurable decision time and end-to-end overhead.
  5. Selective responses plus whole-agent containment when continued operation is unsafe.
  6. Explicit failure behavior and recovery requirements.
  7. Decision evidence that can be checked against the target-system outcome.

A control's name does not establish its coverage. Ask the vendor to demonstrate the paths you use.

Building your broader AI agent security stack? Combine permissions, input and memory protection, monitoring and independent action controls. Ackuity adds execution control; it complements the rest of that stack.

QUESTIONS PEOPLE ASK

Frequently asked questions.

What is an AI agent kill switch?

An AI agent kill switch stops or contains unsafe agent execution. Implementations may operate on a capability, an agent or a wider workflow. Ackuity is an Agent Execution Control Switch that also evaluates each proposed action before it runs.

What is required to implement a kill switch for AI agents?

An enforceable boundary, policy outside the agent's control, documented action and credential coverage, explicit failure behavior, decision evidence and a tested recovery path. Verify what happens to queued work, child agents and downstream sessions.

How do you block AI agent actions in real time?

Intercept the proposed action before the target changes, validate authority and context, then enforce Allow, Constrain, Human in the loop, Block or Terminate. A monitoring event received after execution cannot prevent that action.

Can a kill switch target one agent without stopping everything else?

Some implementations can target one capability, agent or workflow. Check the actual scope and dependencies. Ackuity also makes per-action decisions, with continued execution dependent on the agent and task remaining trustworthy.

Can human approval override a policy violation?

No. In Ackuity's decision model, hard policy boundaries remain enforced. Human review handles ambiguous actions within authorized scope. Approval is tied to that action and context; it does not grant broader permissions or approve future actions.

Can an MCP gateway act as a kill switch?

It can block calls routed through it. Broader containment depends on the deployment and other execution paths. Trace direct database access, shell commands, background work and delegated agents rather than assuming gateway coverage.

Does adding a control switch slow agents down?

Ackuity makes decisions in 40 to 100 ms. This is decision time, not end-to-end overhead. Measure total latency and legitimate-task completion in your own deployment.

What should a human approval record for an AI agent include?

The user and agent identities, exact proposed operation, target environment and affected records, relevant policy version, reviewer authority, expiry, single-use condition and observed downstream result. Treat this as an evaluation checklist: verify which fields and enforcement mechanisms your deployment actually supports.

What if an agent changes an action after approval?

Compare the current proposal with the reviewed scope and policy at execution. A changed target, record set, permission or policy state needs a fresh decision. Approval for one operation does not authorize a different operation or a future repeat.

Is it safe to retry a blocked or timed-out action?

A blocked proposal should return for correction and a new decision. A timeout leaves the target outcome uncertain until its state is checked. Reconcile the result before retrying so the workflow does not perform the same change twice.

NEXT STEP

Agents are going to act. Decide which actions run.

Show us the actions you need to control, and we’ll show you where Ackuity fits.

Request assessment