Human-in-the-Loop Agents With LangGraph

Full automation is not always the right goal. There are tasks where an agent does 90 percent of the work well but the final 10 percent requires a human judgment call. There are actions that are irreversible, such as sending an email to 10,000 users, that should never fire without an approval. There are workflows where you want to review intermediate outputs before the agent continues.

LangGraph handles all of these cases through a pattern called human-in-the-loop. The agent runs, pauses at a checkpoint, waits for human input, and then resumes with that input incorporated into its state. The full execution history is preserved across the pause.

The interrupt_before Pattern

LangGraph's interrupt_before parameter tells the graph to stop before executing a specific node and wait for a human to provide input. The graph state is saved automatically. When the human responds, execution resumes from that exact point.

Here is the key configuration: when you compile the graph, pass a checkpointer (an in-memory or persistent store) and specify which nodes should pause for human input.

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from typing import TypedDict

class ApprovalState(TypedDict):
    task: str
    draft_action: str
    human_approved: bool
    result: str

def plan_action(state: ApprovalState) -> dict:
    return {'draft_action': f'Send campaign email to all users re: {state["task"]}'}

def execute_action(state: ApprovalState) -> dict:
    if state['human_approved']:
        return {'result': 'Email campaign sent successfully'}
    return {'result': 'Action cancelled by reviewer'}

graph = StateGraph(ApprovalState)
graph.add_node('plan', plan_action)
graph.add_node('execute', execute_action)
graph.set_entry_point('plan')
graph.add_edge('plan', 'execute')
graph.add_edge('execute', END)

# Pause before 'execute' and persist state with a checkpointer
checkpointer = MemorySaver()
app = graph.compile(
    checkpointer=checkpointer,
    interrupt_before=['execute']
)

Running the Approval Loop

With interrupt_before set, the graph pauses after the plan node completes and before execute begins. You inspect the draft action, collect a human decision, and resume with the updated state.

# Thread ID keeps the paused state associated with this run
config = {'configurable': {'thread_id': 'approval-run-001'}}

initial = {
    'task': 'Q3 product launch',
    'draft_action': '',
    'human_approved': False,
    'result': ''
}

# Run until the interrupt fires
for event in app.stream(initial, config=config):
    print(event)

# Inspect the pending action
current_state = app.get_state(config)
print('Pending action:', current_state.values['draft_action'])

# Human reviews and decides
human_decision = True  # set False to cancel

# Update state and resume
app.update_state(config, {'human_approved': human_decision})
for event in app.stream(None, config=config):
    print(event)

Where to Use Human-in-the-Loop

The clearest use cases are: any action that sends external communications (emails, Slack messages, webhooks to production systems), any financial transaction, any data deletion, and any agent output that will be published publicly.

Beyond Approval: Feedback and Correction

Human-in-the-loop is not just for approvals. You can also use it to inject corrections. If the agent drafts a report that is 80 percent right, a human can edit the draft in the state and resume. The agent continues from that corrected starting point rather than starting over. This is the pattern that makes AI-assisted workflows genuinely collaborative rather than all-or-nothing.