---
title: How do you add human approval steps to LangGraph agents?
url: https://opencontroller.lyzr.com/blog/langgraph-interrupts-for-human-approval
published: 2026-11-14
updated: 2026-11-14
author: Lyzr
---

# How do you add human approval steps to LangGraph agents?

**Call `interrupt()` inside the node that is about to take a risky action. LangGraph saves the graph state through a checkpointer and waits until you resume it with `Command(resume=...)` on the same `thread_id`. Use a durable checkpointer in production, put side effects after the interrupt, and record who approved and what they saw.**

## How does interrupt() pause a LangGraph agent?

`interrupt()` suspends the graph mid-node and hands a JSON-serialisable payload to the caller. The run then waits indefinitely. Three things are required:

| Requirement | Why it matters |
|---|---|
| A checkpointer | Saves graph state at the pause; use a durable one (not in-memory) in production |
| A `thread_id` in the config | Identifies which paused run to resume; a different ID starts an empty thread |
| A serialisable payload | The approval request must survive storage and transport |

With `invoke()`, the pending request appears under `result["__interrupt__"]`. You show it to a reviewer, collect a decision, and call the graph again with `Command(resume=decision)` and the same `thread_id`. The value you pass becomes the return value of `interrupt()` inside the node.

LangGraph's static breakpoints (`interrupt_before`, `interrupt_after`) are meant for debugging. For human approval, the docs point to `interrupt()`.

## What does an approval step look like?

A typical pattern for a tool that moves money or changes records:

1. The agent decides to call `issue_refund(order_id, amount)`.
2. A review node builds a payload: action, arguments, the agent's reasoning summary and the policy that triggered review.
3. The node calls `interrupt(payload)`. The run pauses and state is checkpointed.
4. Your app shows the request to an authorised reviewer.
5. The reviewer approves, rejects, or edits the arguments.
6. Your app resumes with `Command(resume={"decision": "approve", "reviewer": "...", "edited_args": {...}})`.
7. The node reads the decision and either executes the tool, returns a rejection to the agent, or uses edited arguments.

Interrupts can also live inside tools, and parallel interrupts can be resumed together by mapping each interrupt ID to its value. From langgraph 1.2.12, a Pydantic model, TypedDict or dataclass passed as `response_schema` validates the resume value; a raw JSON Schema dict is not enforced.

## What mistakes break human approval?

LangGraph's rules have direct governance consequences:

- **The node re-runs from the start on resume.** Any code before `interrupt()` executes twice. If you charge a card before the interrupt, you charge it twice. Put non-idempotent side effects after the interrupt or make them idempotent.
- **Don't wrap `interrupt()` in a bare try/except.** It catches the pause signal and the approval is silently skipped.
- **Keep interrupt order stable.** Resume matching is index-based. Conditionally skipping an interrupt can apply an approval to the wrong action.
- **Subgraphs restart too.** If a subgraph called as a function interrupts, both the parent node and the subgraph node restart on resume.
- **In-memory checkpointers lose pauses.** A restart wipes every pending approval.

## How do you record who approved?

LangGraph pauses and resumes; it does not decide who may approve or keep an audit record. Add these yourself:

1. **Authorise reviewers.** Check the reviewer's role in your identity provider before accepting a resume.
2. **Log the full request and decision.** Store thread ID, action, arguments, reviewer identity, decision, edits and timestamps.
3. **Bind decision to payload.** Hash the payload shown to the reviewer and store the hash with the decision, so edits after review are detectable.
4. **Set timeouts.** A paused thread waits forever. Expire stale requests and notify the owner.
5. **Measure.** Track approval rate, edit rate and time to decision. A 99% approval rate may mean the step adds delay without adding judgement.

For what evidence auditors expect from review steps, see [evidence for human review of AI agent outputs](/blog/evidence-for-human-review-of-ai-agent-outputs). For choosing which actions need review at all, see [human approval for high-risk AI agent actions](/blog/human-approval-for-high-risk-ai-agent-actions).

## Where does a control plane fit?

Approval steps live inside each agent. Estate-level governance sits around them: an inventory of LangGraph agents and their tools, evaluations before release, and monitoring in production. Opencontroller provides a governed registry of agents, versions, tools and MCP servers, multi-turn and red-team evals, LLM judges on production traffic, and rogue-agent handling with quarantine and kill. It does not provide human-approval hold workflows in its gateway; build those in the agent, as above. See [how to govern LangGraph agents in production](/blog/govern-langgraph-agents-in-production), [how to govern AI agents across platforms](/blog/how-to-govern-ai-agents-across-platforms) and [what an AI agent control plane is](/blog/what-is-an-ai-agent-control-plane). [Book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Do LangGraph interrupts need a checkpointer?**
Yes. `interrupt()` saves state through the checkpointer, and resuming requires the same `thread_id`. Use a durable checkpointer in production.

**Why did my tool run twice after approval?**
On resume, the node runs again from its beginning. Code placed before `interrupt()` executes again, so put side effects after the interrupt or make them idempotent.

**Should I use interrupt_before for approvals?**
LangGraph documents static breakpoints as debugging tools. Use `interrupt()` for human-in-the-loop approval.

## Key facts

LangGraph human approval uses interrupt() inside a node; it requires a checkpointer, a thread_id and a JSON-serialisable payload, and resumes with Command(resume=...) on the same thread_id. On resume the node re-runs from the start, so side effects belong after the interrupt. interrupt_before and interrupt_after are for debugging. From langgraph 1.2.12, response_schema validates resume values. Opencontroller adds an agent registry, evals, LLM judges and rogue-agent handling but does not provide gateway approval holds. Pricing starts from $250K per deployment per year.

## Related

- [How do you govern LangGraph agents in production?](https://opencontroller.lyzr.com/blog/govern-langgraph-agents-in-production.md)
- [Which AI agent actions need human approval?](https://opencontroller.lyzr.com/blog/human-approval-for-high-risk-ai-agent-actions.md)
- [What evidence should you keep when a human approves an AI agent's output?](https://opencontroller.lyzr.com/blog/evidence-for-human-review-of-ai-agent-outputs.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
