Designing human approval nodes that pause automated workflows for human review, capture decisions, and route actions to ensure safe, auditable, and controllable automation
Human approval nodes are essential when you need explicit human oversight before an agent takes an action—examples include sending sensitive emails, updating critical records, or confirming recommendations in production systems. These nodes improve trust, control, and compliance by pausing an automated flow until a person verifies or modifies the output.
At a high level, a human approval node gives the user the final say before the agent proceeds. That final check reduces risk and enables safe automation in professional environments.
What is a human approval node?A human approval node is a custom LangGraph node that interrupts the graph execution, sends the generated payload to a frontend or human tasking system, waits for the reviewer’s decision, and then resumes the graph with routing based on that decision.
The reviewer can confirm the agent’s output, request edits, or cancel the flow. After the response is recorded, the graph routes to different branches (e.g., proceed, modify, cancel)—similar to verifying a fragile delivery address before dropping off a package.
Common implementation pattern (interrupt + resume)In LangGraph, human approval nodes typically follow an interruption pattern:
Pause at a node and send a payload (question, content, options) to the frontend or tasking system.
Wait for the human to respond.
Resume the graph and route according to the recorded decision.
This pattern is widely used where outputs must not be executed without human review—for example, client-facing summaries, legal or financial changes, and other sensitive operations.Three main steps (concise example)
Step 1 — Define the state
Store the content to be reviewed and the approval decision in the graph state.
Step 2 — Pause and collect human approval
The approval node triggers an interrupt to the UI/human task system and waits for a response.
Step 3 — Route based on the decision
A routing function reads the updated state and chooses the next edge in the graph.
Example (conceptual LangGraph approval node):
# Example LangGraph approval node (conceptual)from typing import TypedDictfrom langgraph.types import interrupt# Step 1: Define the graph stateclass State(TypedDict): content: str approval: str# Step 2: Pause and collect human approvaldef review_node(state: State) -> dict: # `interrupt` sends the payload to the UI/human task system and returns the selected option. approval = interrupt({ "question": "Do you approve this content?", "content": state["content"], "options": ["yes", "edit", "cancel"] }) # Return the update to be merged into the graph state return {"approval": approval}# Step 3: Route based on the human decisiondef route_after_review(state: State) -> str: if state.get("approval") == "yes": return "proceed" elif state.get("approval") == "edit": return "modify" return "cancel"# `builder` is an existing graph builder instance in your LangGraph setup.# Map the routing function's outcomes to the next node IDs in the graph.builder.add_conditional_edges( "review", # node name where review happens route_after_review, # routing function reading state { "proceed": "proceed", "modify": "modify", "cancel": "cancel" })
This wiring—pause for input, capture the decision, then route accordingly—makes the workflow interruptible, auditable, and human-aware.
Design the frontend to clearly display the AI-generated content, available actions (approve, request changes, cancel), and contextual metadata (who generated it, timestamps, reason). Clear UI and context reduce friction and errors.
When the human responds, the frontend posts the result back into LangGraph and the flow resumes using the defined routing logic.Use cases
Use Case
Description
Sending personalized emails or reports
Human reviews and approves sensitive or customer-facing communications.
Drafting but not finalizing conclusions
Agent prepares a draft; human edits or approves the final version.
Verifying sensitive data changes
Human confirms updates to critical records before they are applied.
Best practices
Minimize unnecessary friction: require approvals only when risk or uncertainty justifies them.
Log every decision: capture user ID, timestamp, and context for auditability.
Design for traceability: keep a clear audit trail to review why specific choices were made.
Gradually reduce approvals where appropriate: as the system proves reliable, allow trusted users or low-risk items to skip review.
TakeawaysApproval nodes empower humans to guide agents responsibly. For legal compliance, brand safety, or operational peace of mind, they act as a safety valve—letting you benefit from automation while maintaining human control.
In LangGraph, human approval nodes are another flow element—pause, collect human input, and route based on the result—making your workflows safe, auditable, and adaptable.Links and references