> ## Documentation Index
> Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Designing Human Approval Nodes
> 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):
```python theme={null}
# Example LangGraph approval node (conceptual)
from typing import TypedDict
from langgraph.types import interrupt
# Step 1: Define the graph state
class State(TypedDict):
content: str
approval: str
# Step 2: Pause and collect human approval
def 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 decision
def 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.
Takeaways
Approval 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
* [LangGraph documentation](https://langgraph.ai/docs)
* [Human-in-the-loop (HITL) design patterns (overview)](https://en.wikipedia.org/wiki/Human-in-the-loop)