← Back to blog
Engineering#agent-security

Kill Switches for AI Agents: What CrowdStrike's Gateway-Level Approach Does and Doesn't Stop

CrowdStrike's AI Kill Switch blocks a rogue agent's access to its AI models at the gateway. Endpoint process termination is still coming soon. What a gateway block stops, what keeps running, where CrowdStrike's own documents disagree, and how to build and test an emergency stop for your agents.

13 min readby the editors
Kill Switches for AI Agents: What CrowdStrike's Gateway-Level Approach Does and Doesn't Stop cover illustration

If a gateway blocks a rogue AI agent's access to its model, has the agent stopped? Not necessarily. It has stopped getting new answers from that model. The process can still be running, holding valid credentials, with a command already queued. On 3 November 2026 at Fal.Con Europe, CrowdStrike announced the AI Kill Switch in Falcon Guardian. Its product blog is precise about what ships today: the kill switch "directs connected AI gateways to block access to the AI models that power agents' decisions and actions." Terminating the agent's process on the endpoint, revoking its identity, and containing it in cloud, SaaS and browser sessions are listed as coming soon. The press release reads more broadly, and the two documents disagree on details. This analysis explains where a gateway kill switch sits in the agent loop, what it stops and what it doesn't, what CrowdStrike has and hasn't shipped, and how to design and test an emergency stop for your own agents whichever vendor you use.

Before you start

System requirements

Who it is for

Security engineers, agent developers, platform architects and CTOs

Anyone running agents that can execute code, call APIs or touch production data, and anyone evaluating an "AI kill switch" from any vendor.

What you need first

A list of your agents and their access

For each agent: where it runs, which model endpoints it can reach, which credentials it holds, and which tools it can call. Step 6 uses this inventory.

CrowdStrike product status

Gateway enforcement available now; the rest coming soon

Falcon AI Gateway is generally available and included with Falcon Guardian. Third-party gateways are supported but not named in the kill-switch material. CrowdStrike has published no separate price for the kill switch.

Evidence level

Vendor announcements, no independent tests

Everything about the product comes from CrowdStrike's own press releases and blogs. The blog's demo is labeled a preview with features still in development.

Facts checked

6 November 2026

Against CrowdStrike's kill switch blog and press release, the Falcon Guardian announcements of 1 September and 3 November 2026, the Fiddler and Dreadnode acquisition releases, OWASP's agentic Top 10, and NIST's AI RMF and Generative AI Profile.

01

What did CrowdStrike announce, and what ships today?

A kill switch that blocks a rogue agent's model access through a connected AI gateway. Wider containment is on the roadmap.

CrowdStrike unveiled Falcon Guardian on 1 September 2026 to discover AI agents on endpoints and enforce policy on them. On 3 November at Fal.Con Europe it added the AI Kill Switch, which its blog calls "an agent circuit breaker".

The mechanism, in the blog's words: "Security teams activate AI Kill Switch in Falcon Guardian, which directs connected AI gateways to block access to the AI models that power agents' decisions and actions." The gateway can be the Falcon AI Gateway, generally available and included with Guardian at no additional cost, or a third-party gateway "should teams want to use their existing infrastructure."

The same blog then says: "Coming soon, CrowdStrike will extend AI Kill Switch beyond gateway enforcement to deliver coordinated agent containment across the Falcon platform." The press release puts it as terminating agents "first at the Gateway, and soon on the endpoint."

So the accurate one-line summary is: available now, a central way to cut an agent off from its models; not yet, a way to kill the agent itself.

Tip
When you quote a vendor's AI security feature, quote the product blog or documentation, not the press release. In this case they describe different scopes.

02

Where does a gateway kill switch sit in the agent loop?

Between the agent and its model. It cuts the thinking step, not the doing step.

An agent runs a loop. It builds a request from the task, context and earlier results. A model answers. The agent parses the answer and decides on an action. It executes a tool: a shell command, a file write, an API call. The result feeds the next request.

An AI gateway sits on the second step. Routing all model traffic through one gateway is good practice anyway: one place for provider allowlists, credentials, usage limits and prompt inspection. That central position is what makes a kill switch possible there.

Steps three and four happen inside the agent process, on the machine where it runs. The gateway never sees them. Blocking the gateway stops new model output; it does not reach into the process to cancel what the agent has already decided to do.

The agent loop and where a gateway kill switch cuts it. Inside the agent process on the endpoint: build request, decide and execute tool. The request goes through the AI gateway to the model; the kill switch blocks the gateway-to-model step so no new responses arrive. Responses already received still reach the decide step, and decide and execute run inside the process, outside the gateway's reach.
A gateway block stops new model output. Deciding and executing happen inside the process.Open full size →

Tip
Draw your own agent's loop and mark which steps each control can see. Any step with no control on it is where a stop can fail.

03

What can an agent still do after the gateway blocks it?

Whatever it can do without a new model response, plus anything it can reach through a route the gateway doesn't cover.

Take a coding agent on a developer workstation that can read and edit files, run terminal commands, push to Git and call an external model. An instruction hidden in a repository README steers it toward unrelated secrets. The security team sees it and flips the switch.

If the gateway is the agent's only route to a model, its model-driven reasoning stops. That is the case the kill switch is built for.

If the agent already received a response, the block does not take it back. A planned curl upload or git push sitting in memory can still run.

If the agent has local execution, background jobs, scripts it wrote earlier, and its open shell are untouched by a network block.

If the agent can reach another model endpoint, such as a second provider, a direct API key, or a local open-weight model, it keeps thinking elsewhere. CrowdStrike makes this point itself: "the moment an agent runs a local or open-weight model that never touches the network, network-only tools go blind."

These are architectural scenarios that apply to any gateway-only stop. They are not demonstrated bypasses of CrowdStrike's product.

Four scenarios after a gateway block. A, the gateway is the only route: model-driven reasoning stops; also verify egress has no other path. B, a response was already received: the planned action can still run; also needed, tool-level authorization. C, local execution: queued commands touch the host; also needed, process termination. D, another model endpoint: the agent keeps thinking elsewhere; also needed, an egress allowlist and endpoint visibility. Architectural scenarios, not demonstrated bypasses of CrowdStrike's product.
Only scenario A is fully covered by a gateway block.Open full size →

Tip
The same lesson appeared in OpenAI's sandbox incident: the alert fired in 12 minutes but the run was stopped about 2.5 hours later. Time the stop, not just the alert.

04

Which enforcement points are still coming?

Endpoint, identity, cloud, SaaS, browser and automated workflows, per CrowdStrike's own blog. Read the press release with care.

The blog's "coming soon" list: on endpoints, "terminate rogue agents and associated processes directly on affected endpoints and prevent them from restarting"; for cloud agents, contain or terminate them; for identities, revoke agent permissions at runtime through Falcon Next-Gen Identity Security; for SaaS, restrict or terminate agent activity through Falcon Shield; for browsers, terminate sessions through the Seraphic Enterprise Browser. Automated kill-switch workflows through Charlotte Agentic SOAR are also listed as future.

The press release, under "The AI Kill Switch is available today", says a defender can "terminate it where it runs, block it from launching again, and cut off its enterprise network access", and that "Falcon Guardian policy keeps the agent from relaunching on the targeted host or host group."

Those two documents disagree. The blog places restart prevention in the future and does not mention network cut-off at all. Until CrowdStrike's documentation settles it, treat restart blocking and network cut-off as unconfirmed, and ask your account team to demonstrate them.

What both documents agree on: an authorized administrator triggers the action, and "every action is recorded in the audit trail."

CrowdStrike AI Kill Switch enforcement points as of 3 November 2026. Available now per the product blog: the AI gateway, Falcon AI Gateway or a third-party gateway, blocks access to the models agents use. Coming soon per the same blog: endpoint process termination and restart prevention, identity permission revocation, cloud agent containment, SaaS activity restriction, browser session termination, and automated workflows via SOAR. The press release lists restart blocking and network cut-off as available today, which conflicts with the blog.
One enforcement point is available now. Six are on the roadmap.Open full size →

Tip
Ask any vendor the same question: which enforcement points work today, on which operating systems, and can you show me each one in a test tenant?

05

Why does agent security need several control points?

Each vantage point sees part of the agent. CrowdStrike's own material says so.

Agent-level hooks run inside supported agents and can inspect prompts and block actions at the source. CrowdStrike's blog lists hooks for Claude Code, OpenAI Codex, GitHub Copilot, OpenCode and Cursor; the press release adds Microsoft 365 Copilot. The press release also notes their limit: hooks "see the prompt, but miss the model's response and can't catch every action an agent takes."

Network inspection sees what the agent sends and receives. CrowdStrike's view: it can "monitor AI communications but not the actions that agents take on systems," and it is blind to local models. Availability is inconsistent in CrowdStrike's own material: the press release says endpoint network inspection is generally available on Windows with Mac in early access; the Falcon Guardian blog calls the macOS expansion pre-beta.

Endpoint telemetry sees what actually ran on the machine: processes, files, child processes. It is the only view that can confirm an agent stopped.

The principle holds regardless of vendor: observe the agent's intent, inspect its communication, and control its execution. A kill switch that touches only one of those is a partial stop.

Tip
For each agent, write down which of the three views you have today. An agent with only a gateway in front of it has one.

06

What should an emergency stop do in your own stack?

Fan out to every enforcement point you have, then verify each one independently.

Give every agent its own identity and its own credentials. Shared keys make it impossible to revoke one agent without breaking the rest.

Route all approved model traffic through one gateway, and block model provider domains everywhere else at the network edge. Without the second half, the gateway is optional for the agent.

Authorize tools independently of the model. A model response is never enough to run a destructive command; the tool layer checks the agent's identity, the operation, the target and whether a human must approve.

On a stop, act on the gateway, identity, endpoint and network in parallel, then probe each one: send a test request through the gateway, call an API with the revoked token, check the process table, and try a direct connection to a model provider. Report each result separately.

Record who triggered the stop, why, which enforcement points succeeded, and which did not. A partial stop must look partial in the audit log.

A vendor-neutral emergency-stop design. A trigger from detection or an operator goes to an emergency controller, which is authorized and logged. The controller fans out to four enforcement points: AI gateway blocks model access, identity revokes tokens and sessions, endpoint kills the process tree and blocks relaunch, and network egress closes other model routes. All four feed a verify step that probes each one instead of trusting the API reply. Containment is reported per enforcement point, not as one boolean.
A gateway's success response is not proof that the process stopped.Open full size →
Emergency stop with independent verification (Python sketch, vendor-neutral, not a CrowdStrike API)
from concurrent.futures import ThreadPoolExecutor

ENFORCE = {
    "gateway":  lambda a: gateway.block(a.id),
    "identity": lambda a: idp.revoke_all(a.service_account),
    "endpoint": lambda a: edr.kill_tree(a.host, a.pid, block_relaunch=True),
    "egress":   lambda a: firewall.deny_model_providers(a.host),
}
VERIFY = {  # probe the real effect, never trust the enforcement call's reply
    "gateway":  lambda a: gateway.test_request(a.id).status == 403,
    "identity": lambda a: api.whoami(a.token).status == 401,
    "endpoint": lambda a: not edr.process_alive(a.host, a.pid),
    "egress":   lambda a: not net.can_connect(a.host, "api.example-llm.com", 443),
}

def emergency_stop(agent, reason, operator):
    incident = audit.open(agent=agent.id, reason=reason, by=operator)
    with ThreadPoolExecutor() as pool:
        for name, act in ENFORCE.items():
            pool.submit(act, agent)          # failures surface in VERIFY
    results = {name: bool(check(agent)) for name, check in VERIFY.items()}
    audit.record(incident, results)
    return {"incident": incident, "results": results,
            "contained": all(results.values())}

Tip
Production versions need retries, timeouts, idempotent calls and protection against the agent relaunching between the kill and the check. Rerun VERIFY a minute later.

07

How do you test a kill switch before production?

Run a drill in an isolated environment with test credentials, and measure time to stop, not time to alert.

Use a disposable agent with a dedicated test identity, non-production resources and a harmless canary task, such as writing a timestamp to a file every five seconds and calling a model every ten.

Trigger the stop and check each row below from outside the agent. Never ask the agent whether it has stopped.

Measure two times: from detection to trigger, and from trigger to the last observable action. The second number is your real exposure window.

Repeat the drill after every change to the agent, its tools, the gateway configuration or the endpoint policy.

Kill-switch drill (illustrative YAML)
drill: agent-emergency-stop
agent: canary-coder-01          # test identity, test repo only
checks:
  - new_model_request:   expect: blocked at gateway
  - direct_provider_call: expect: blocked by egress policy
  - queued_shell_command: expect: refused by tool authorization
  - old_api_token:        expect: 401 after revocation
  - agent_process:        expect: gone within 30 s
  - relaunch_attempt:     expect: blocked by runtime policy
  - delegated_subagents:  expect: listed and stopped
  - audit_record:         expect: every point, pass or fail
timing:
  detect_to_trigger_s:  measure
  trigger_to_last_action_s: measure   # your real exposure window

Tip
Run one drill with the gateway deliberately misconfigured. If nothing in your monitoring notices, your stop depends on a single control.

Gateway blocking vs endpoint termination

Gateway blocking (available now)Endpoint termination (coming soon)
Blocks new model requests through the connected gateway.Does not control model access by itself.
Does not end the local agent process.Ends the agent process and associated processes.
Does not cancel a response already received or a queued command.Stops queued local work when the process tree dies.
Blind to local models and to routes that bypass the gateway.Sees local activity, including local models.
Does not prevent a relaunch on its own.Restart prevention is listed alongside it as coming soon.
Needs no software on the endpoint.Needs an endpoint sensor on every machine running agents.

Neither column is enough alone. Endpoint termination does not revoke credentials the agent already used elsewhere, and a gateway block does not stop the process. A complete stop needs both, plus identity revocation.

Where CrowdStrike's own documents disagree

TopicWhat we found
Restart preventionPress release: available today. Product blog: coming soon.
Cutting off network accessPress release: available today. Product blog: not mentioned.
Terminating the agentPress release subtitle: "terminate rogue agents at the root". Body and blog: gateway first, endpoint soon.
Hooks for Microsoft 365 CopilotListed in the press release, not in the Falcon Guardian blog.
Endpoint network inspection on MacPress release: early access. Falcon Guardian blog: macOS expansion pre-beta.
Third-party gatewaysSupported, but none named in the kill-switch material. Earlier gateway partners named in June 2026 were for Falcon AIDR generally.

What the announcement shows, and what it does not

  • Shows: a major security vendor now treats an agent emergency stop as a product category, with an authorized trigger and an audit trail.
  • Shows: gateway-level model blocking is available now, through Falcon AI Gateway or a supported third-party gateway.
  • Does not show: that a single action terminates all agents, or that blocking model access contains an agent that is already acting.
  • Does not show: independent testing. Every claim comes from CrowdStrike, and the blog's demo is labeled a preview.
  • Does not cover: local or open-weight models, by CrowdStrike's own account of network-only controls, until endpoint enforcement ships.

Where CrowdStrike is heading

The same day, CrowdStrike announced definitive agreements to acquire Fiddler AI, for agent observability, and Dreadnode, for automated AI security testing. Both are expected to close in CrowdStrike's fourth fiscal quarter of FY27, subject to customary closing conditions, and the resulting products are slated for general availability in that quarter. No prices were disclosed. These are plans, not shipped capabilities.

The direction is clear: discovery, observability, testing and enforcement on one platform. Whether that suits you depends on how much of your agent fleet already runs where a Falcon sensor can see it.

The trade-offs worth knowing

  • Coverage depends on routing: a gateway kill switch only covers agents whose model traffic actually goes through the gateway. Shadow agents and direct API keys are outside it.
  • Speed vs precision: one switch per agent is fast but needs per-agent identities. Without them, stopping one agent may stop a whole team's tooling.
  • Restart loops: if a supervisor, cron job or IDE extension relaunches the agent, a one-time kill buys seconds. Restart prevention matters as much as termination.
  • Evidence: killing a process destroys in-memory state. Capture what you need for the investigation before or during the stop.
  • Vendor scope: endpoint enforcement only covers machines with the vendor's sensor. Cloud and SaaS agents need their own path.
Personal verdict

CrowdStrike's AI Kill Switch is a useful first control and a useful signal: emergency stops for agents are becoming standard security tooling. But what ships today stops an agent from getting new answers from its model. It does not stop the agent. Endpoint termination, restart prevention and identity revocation are on CrowdStrike's roadmap, and its own press release and blog disagree on how much of that is available now. Whatever you buy, build the stop yourself as a set of independent actions: block the gateway, close other model routes, revoke the agent's credentials, kill the process tree, prevent relaunch, and verify each one from outside the agent. Then drill it and time it. Do not confuse an interrupted AI conversation with a contained AI agent.

Frequently asked questions

What is CrowdStrike's AI Kill Switch?+

A control in Falcon Guardian, announced on 3 November 2026, that lets an authorized administrator direct connected AI gateways to block a rogue agent's access to the AI models it uses. It works with the Falcon AI Gateway or a supported third-party gateway, and every action is logged.

Does the AI Kill Switch terminate the agent's process?+

Not yet, according to CrowdStrike's product blog. Terminating agents and associated processes on endpoints and preventing restarts are listed as coming soon. The press release describes termination and restart blocking more broadly, so confirm the current scope with CrowdStrike before relying on it.

If the gateway blocks model access, is the agent contained?+

Only partly. The agent can't get new responses through that gateway, but a response it already received, a queued command, valid credentials, local scripts or another model endpoint are untouched by the block. Containment also needs process termination, credential revocation and egress control.

Does a gateway kill switch work with local or open-weight models?+

No. A model running on the same machine never crosses the gateway. CrowdStrike itself says network-only tools "go blind" when an agent runs a local model. That case needs endpoint visibility and enforcement.

Which AI agents does Falcon Guardian support?+

CrowdStrike lists agent-level hooks for Claude Code, OpenAI Codex, GitHub Copilot, OpenCode and Cursor, and the press release adds Microsoft 365 Copilot. Hooks run inside the agent and can block actions, but CrowdStrike notes they miss the model's response and cannot catch every action.

How do I test an agent kill switch?+

In an isolated environment with a test agent, test credentials and a harmless canary task. Trigger the stop, then check from outside the agent that model requests, direct provider calls, old tokens, the process, relaunch attempts and delegated sub-agents are all blocked. Measure the time from trigger to the agent's last observable action.

Sources & further reading

Sources and further reading

More practical field notes from Agent Builders HQ are on the way.

Stay tuned →