Implementing Runtime Kill Switches for LangGraph Agents to Support NYDFS Part 500 Incident Response
A LangGraph agent kill switch should be a set of tiers enforced outside the graph, in the path of tool calls and credentials: a per-tool block, a per-agent halt, and escalation to a human approver, with credential revocation as a backstop. Each tier should emit evidence showing the policy in force, the trigger, the actions blocked, the approver and timestamps. That evidence is what lets a covered entity show an examiner how an agent was contained.
Define the tiers and where each one sits
- 1
Per-tool block
Sits at the tool-call boundary, between the graph and the API, data store or MCP server it calls. A policy decision is made per call, so a compromised or misbehaving tool can be denied while the rest of the agent continues. Egress allowlists and permission restrictions are the same idea at the network layer.
- 2
Per-agent halt
Sits in the execution path for every interaction the agent makes. Once set, every subsequent model call and tool call from that agent is denied, regardless of which checkpoint, retry or branch issues it. This is the tier that addresses resumption and fan-out.
- 3
Human approval escalation
Sits at the same boundary, but holds a call pending a decision instead of denying it. Set explicit risk thresholds, route escalations to a named authority, and limit volume so approvals do not become habitual.
- 4
Credential revocation
Sits at the identity layer. It removes the agent's authority to reach downstream systems and works even if enforcement in the path is bypassed, but it is coarser and takes effect only as fast as downstream systems honor it.
Evidence each kill switch event should produce
- Policy in force at the time of each decision, with version and scope
- Triggering condition and who or what initiated the tier
- Actions blocked, including rejected tool calls and retries
- Approver identity and decision for every escalation
- Timestamps for trigger, enforcement and last permitted action
- Preserved checkpoints and network logs for the affected trajectory
Why an application flag is not a kill switch
The simplest design is a boolean the agent checks before it acts. It works only if every path through the graph reads the flag at the right moment, and an incident is exactly when that assumption is weakest. The control depends on the cooperation of the code it is meant to contain.
Stateful agent graphs create specific gaps. A graph that persists checkpoints can be resumed after a halt, restoring state from before the flag was set. Retry logic can re-issue a tool call that was just denied. Parallel branches can be mid-flight when the signal arrives, and a single node can fan out into many tool calls. In each case, the agent may keep acting after an incident is declared unless the stop is applied somewhere the graph cannot route around.
The design principle is that containment should sit outside the agent's own control flow. Revocable, short-lived authorization and shutdown at the level of the affected trajectory, rather than only the whole process, are both described in current NIST material on agent identity and incident readiness. Both point to controls that operate independently of application code.
Containment trade-offs (design analysis)
The comparison below is design analysis, not measured data. Validate latency and completeness in your own environment, since they depend on where enforcement sits and how credentials are issued.
- Per-tool block: Granularity: single call or destination. Completeness: narrow by design. Reversibility: high, the policy can be lifted immediately.
- Per-agent halt: Granularity: whole agent. Completeness: high if enforced in the path for all calls. Reversibility: high, but restart should follow verification.
- Human approval escalation: Granularity: individual action. Completeness: depends on threshold design. Reversibility: each decision is recorded, and added latency is the cost.
- Credential revocation: Granularity: all access under that identity. Completeness: high for downstream systems, with possible lag from cached or long-lived tokens. Reversibility: requires reissuing authority.
Mapping enforcement to Part 500 incident response
Section 500.16 was retitled "Incident response and business continuity management" in the second amendment. The agent kill switch belongs in that program as a documented containment procedure, with the same triggers, owners and escalation paths as other incident response steps. Confirm the exact operative requirements against the full regulation text as of November 2026 before mapping specific procedures to it.
Part 500 also requires a covered entity to notify the superintendent electronically, as promptly as possible and no later than 72 hours after determining that a cybersecurity incident has occurred at the covered entity, its affiliates or a third-party service provider. Two implications follow. First, the time of determination should be recorded in a way you can evidence, so the notification workflow can start from a defensible timestamp. Second, tool providers and model providers used by agents fall within the third-party scope, so their incident obligations should be reviewed on that basis.
NIST AI RMF guidance on post-deployment monitoring also supports documenting override, decommissioning, incident response and recovery for deployed AI systems. For model risk management teams, the kill switch tiers become the documented override mechanisms, and the evidence becomes proof they operated.
Verify containment, then evaluate the enforcement model
Before a halted agent restarts, confirm that monitors, logging, egress allowlists, shutdown mechanisms and permission restrictions are functional. Record that verification as part of the incident file. Restarting from a stale checkpoint without it risks reproducing the original condition.
When comparing approaches, ask whether enforcement happens in the execution path or depends on the graph reading a flag, and whether review happens at runtime or after the fact. After-the-fact review can describe an incident, but it cannot stop an action in progress. Also ask whether the control can act on individual interactions and tool calls, with allow, redact, block, rate limit or escalate outcomes, and how a halt's speed is measured and evidenced.
Trussed enforces policy in the execution path across models, agents, tools and MCP servers, with allow, redact, block, rate limit and escalate for human approval at the level of individual interactions and tool calls. It generates audit-ready evidence from that enforcement, mapped to frameworks including NYDFS and NIST. It does not provide end-to-end tracing of agentic workflows. Its production record is 18+ months in a regulated enterprise, and its depth is in insurance rather than banking or broker-dealer deployments.
Kill switch tiers and the evidence each produces
Tier 1: per-tool block
Denies a specific tool call or destination without stopping the agent.
Tier 2: per-agent halt
Stops all further actions by an affected agent, including resumed and parallel work.
Tier 3: human approval
Routes actions that cross a risk threshold to a named authority.
Backstop: credential revocation
Removes the agent's authority at the identity layer.
Evidence record
Policy in force, trigger, blocked actions, approver and timestamps.
Review your agent containment design
Walk through kill switch tiers, enforcement points and evidence requirements for your agents with a Trussed expert.
Explore Agent and Tool-Call EnforcementHow does your AI governance program compare?
See where your program has gaps in less than 2 minutes.