How to Add Human Approval Gates to a LangGraph Workflow

November 14, 2026

An agent that can send emails or update a database should not run unsupervised. Most teams discover this after the first accidental bulk email. LangGraph builds the fix into the framework: interrupt_before pauses the graph before a named node, saves state to a checkpointer, and waits for you to resume.

The mechanics are simple. The design decisions around them are not — what to pause on, what to show the reviewer, and what happens if approval never comes.

How does an interrupt actually work?

Three pieces: a checkpointer, a compiled graph with interrupt_before, and a resume call with the same thread ID.

from langgraph.checkpoint.memory import MemorySaver

memory = MemorySaver()
app = graph.compile(checkpointer=memory, interrupt_before=["send_email"])

config = {"configurable": {"thread_id": "campaign-42"}}
app.invoke(state, config)          # runs until the gate, then stops
app.invoke(None, config)           # resumes from the checkpoint

That is the entire flow. The state survives between calls because the checkpointer holds it.

What should you check before resuming?

The state that got frozen. After the pause, app.get_state(config) returns the values plus the next node. Inspect it before deciding.

What to show a human reviewer:

  • The exact payload the agent is about to act on: recipient list size, subject line, total amount.
  • The decision the agent made and a one-line reason.
  • What happens on approval: how many emails, which database rows.

A generic “approve?” button trains people to click yes. A payload summary trains them to look.

Which checkpointer should you use?

MemorySaver for development. It lives in Python memory, so a process restart loses every paused workflow.

For anything real, use SQLite or Postgres. The LangGraph docs ship SqliteSaver and PostgresSaver; Postgres is the production default for teams that already run one.

Without persistence, a paused workflow that waits overnight dies with the process. This is the most common bug in first implementations.

What happens if nobody approves?

Nothing. The thread sits with a checkpoint and no worker. Unfinished workflows pile up silently.

Handle it explicitly:

  1. Store a created_at timestamp in state before the interrupt.
  2. Run a nightly job that resumes or cancels threads older than N hours.
  3. Cancel by resuming with a state flag the next node checks, or by deleting the checkpoint thread.

Approval queues that nobody monitors are worse than no approval step, because they create the appearance of governance.

When should the gate be a hard stop versus a soft one?

Hard stop for irreversible actions: sending external email, charging a card, deleting records, deploying code. These should never resume without a human.

Soft stop for reversible actions with a delay window: publishing a draft, tagging records, generating invoices. Let the agent act and give a human a 24-hour undo window instead. Approval fatigue is real, and a gate on everything means a gate on nothing.

What does this cost in latency?

A gated workflow is not real-time. Typical implementations see hours between the agent pausing and a human approving, so design any user-facing flow around async.

For internal tooling that is fine. For customer support bots, an approval gate in the middle of a conversation is the wrong shape — use a draft-and-confirm pattern inside the reply instead.

What about multi-step approvals?

Chain the interrupts. interrupt_before=["send_email", "charge_card"] pauses at each, and each resume continues to the next gate.

Keep the chain short. More than two gates on one workflow and reviewers start approving in bulk without reading, which defeats the entire purpose.

Quick Summary

  • LangGraph pauses with interrupt_before, saves state via a checkpointer, and resumes with invoke(None, config) on the same thread ID.
  • Use Postgres or SQLite checkpointers in production; MemorySaver loses paused workflows on restart.
  • Show the reviewer the exact payload and count, not a generic approve button.
  • Add a nightly cleanup job, or unapproved threads accumulate forever.
  • Gate irreversible actions hard; let reversible ones through with an undo window to avoid approval fatigue.