LangGraph Interrupts vs Runtime Approval: What Each Provides Before an Agent Writes to the EHR
Neither mechanism is HIPAA compliant on its own, because HIPAA requires demonstrable safeguards and audit controls and does not prescribe a tool. A LangGraph interrupt is a sound workflow pattern for pausing a graph for a human decision, but it lives in application code and covers only the graphs built to use it. Runtime approval enforced in the execution path applies to the tool call itself, regardless of which agent or framework issues it, and produces evidence outside application code. For EHR writes in a regulated enterprise, an interrupt alone is usually insufficient. The two work best as complementary layers.
Evaluation questions before an agent writes to the EHR
- Does approval apply to every path that can write to the EHR, or only to graphs that implement the interrupt?
- Can a developer or another agent invoke the write tool without passing the approval step?
- Is the approver authenticated, and is that identity recorded with each decision?
- For each approved or blocked write, is a record stored with requesting agent, tool, target resource, approver, decision, timestamp, and outcome?
- Can an auditor retrieve those records independently of application logs the deploying team can alter?
- Who confirms the mapping of the evidence to 164.312(b), and when is it rechecked?
Two mechanisms, two enforcement locations
A LangGraph interrupt is a framework-level pattern. Graph execution pauses at a defined point, a person reviews the proposed action, and the graph resumes with that decision. It is a legitimate design for clinical review workflows, and it gives reviewers a natural place in the flow to approve or reject a proposed action.
Because the interrupt is written into the graph, its behavior depends on how each graph is built: which nodes include it, which tools it covers, how the approver is identified, and where the decision is stored. Each of those is an application design choice.
Runtime approval enforced in the execution path works at a different layer. The tool call itself, such as a write through a FHIR or HL7 interface, is evaluated by policy before it reaches the EHR. The outcome can be to allow it, block it, or escalate it to a human approver. The mechanism does not depend on which agent or framework made the call.
The useful question is narrow: where does enforcement occur, and what evidence does it generate?
Side-by-side evaluation for EHR write actions
The table applies six criteria to each mechanism. The descriptions reflect general architectural properties and assume a typical implementation. Your own graphs and infrastructure determine the actual result.
- Enforcement location: Interrupt: inside application graph code. Runtime approval: at the tool-call boundary, in the execution path.
- Coverage across agents and tools: Interrupt: only graphs that implement it, so each new agent or framework needs its own. Runtime approval: any agent or framework whose calls pass through the path.
- Bypass resistance: Interrupt: a code path that reaches the write tool outside the interrupted node, or a different agent, can skip it. Runtime approval: direct invocation still meets the enforcement point, provided EHR credentials are reachable only through it.
- Approver identity and decision capture: Interrupt: whatever the team builds, including authentication and storage. Runtime approval: can be captured centrally with each decision, if the mechanism is designed to do so.
- Evidence durability: Interrupt: state kept to resume a workflow serves continuation, and application logs may be alterable by the deploying team. Runtime approval: the decision record is produced outside application code, with its own retention.
- Mapping to audit controls: Interrupt: mapped per application. Runtime approval: evidence fields can be standardized across agents and mapped once.
What HIPAA does and does not ask for
The HIPAA Security Rule establishes national standards to protect electronic protected health information that a covered entity or business associate creates, receives, uses, or maintains. An agent that writes to an EHR acts on ePHI, so the entity's obligations attach no matter which agent framework is used. The technical safeguards at 45 CFR 164.312 apply in accordance with 164.306, the general rules for security standards.
Nothing in that structure names interrupts or runtime enforcement. This is why no mechanism should be described as HIPAA compliant by itself. The practical test is whether you can demonstrate the safeguards you chose, including the audit controls under 164.312(b), and retrieve evidence of what an agent was allowed to do and what it did. Read the full text of 164.312 and 164.306 before mapping any control.
Two governance points follow. First, HealthIT.gov notes that organizations must continue to review, correct or modify, and update security protections, so approval controls should be rechecked on a schedule. Second, a HIPAA Security Rule cybersecurity proposed rule published in January 2025 is still listed as a proposed rule on HHS.gov as of November 2026. Governance documents should name the rule version relied on and the review date.
If a vendor or platform touches PHI, a business associate agreement is required, and the business associate is directly liable for certain provisions of the HIPAA Rules.
Three EHR write scenarios
These scenarios are illustrative assumptions, not descriptions of a specific deployment.
In the first, one graph has one write tool for updating a patient record, and an interrupt precedes the call. A clinician sees the proposed write and approves or rejects it. This works well for the reviewer experience. The remaining question is evidence: whether the approver's authenticated identity, the exact payload, the decision, and the outcome are stored somewhere durable and independent of the application.
In the second, another team ships a different agent that calls the same EHR write function, possibly from another framework. The approval step existed only in the first graph, so the second agent has no pause at all. The organization's policy was real, but it was enforced in one place and not across the estate.
In the third, a developer adds a convenience path or a sub-agent that calls the write function directly. The interrupt is intact and never reached. An auditor asking for every blocked and every approved write over a period will find the answer scattered across application logs, if it exists at all.
Each failure is about enforcement location and evidence, not about the quality of the interrupt pattern.
When the mechanisms are complementary and when an interrupt is not enough
The two layers solve different problems. An interrupt shapes the workflow: where a human sees the proposal, what context they get, and how the graph continues. Runtime approval is the control that holds across agents: no write reaches the EHR without a policy decision, and every decision produces a record. Keeping both lets the workflow stay usable while enforcement stays consistent.
An interrupt alone is insufficient when several agents or frameworks can reach the same system of record, when the write target is clinical, when approver identity must be authenticated and retained, or when an auditor needs evidence that does not depend on application logs. It can be adequate for a contained prototype that handles no PHI and has no path to production systems.
Runtime enforcement has tradeoffs. It adds a dependency in the path, requires explicit policy about which writes need approval, and requires approver availability when a call is escalated. Those costs are easier to manage when they are designed in up front.
Trussed is one example of the runtime approach. It enforces policy in the execution path across models, agents, tools, and MCP servers, and can allow, redact, block, or escalate a tool call for human approval. Its scope is individual interactions and tool calls. It generates audit-ready evidence mapped to HIPAA, and it runs in production with healthcare and pharma organizations.
Where approval is enforced
Framework-level interrupt
Pauses a graph for a human decision. Defined inside each graph's application code.
Runtime approval
Evaluates the EHR write tool call in the execution path, whichever agent issues it.
Evidence
Each approved or blocked write needs a durable record an auditor can retrieve.
Review how approval is enforced for your agents' EHR writes
See how policy enforcement in the execution path escalates tool calls for human approval and produces audit-ready evidence.
See How Evidence Is Produced