LangGraph AI Workflow: State, Interrupts, and Human Review

LangGraph models a workflow as a directed graph: nodes are actions, edges are transitions, and the graph holds an explicit state object that each node reads and updates. This makes the workflow's structure visible and its state transitions testable.

The key design decisions are where to put interrupt points — where the graph pauses for a human — and what to do with the decisions a human makes there. Tools like fenbs hold those decisions and the handoff record outside the graph, so they persist across runs and sessions regardless of which model or agent continues the work. AI workflows for education, research, and advertising are covered on their own pages.

How LangGraph models state

Every LangGraph graph has a state schema: a typed object that each node receives and returns. Nodes read from the state, do their work, and return an update. The graph merges the update into the current state and routes to the next node.

Design the state schema before writing any nodes. The schema is the contract between nodes. A field added to the state but not read by any node is dead weight. A field a node needs but that is not in the schema causes a runtime error rather than a design review.

Use LangGraph's built-in persistence when you need the state to survive between runs. The checkpointer stores the state after each node, so a graph interrupted midway can be resumed from the last successful node rather than restarting.

Resumable steps and graph checkpointing

LangGraph's checkpointer persists the state after each node completes. Combined with a thread id, this lets you resume a graph from any previous state. Pass the same thread id to a new run, and the graph resumes from where the previous run stopped.

Choose a checkpointer that matches your durability requirements. A memory checkpointer works for development and tests; a database-backed checkpointer is needed for production workflows that must survive process restarts. Check LangGraph's current documentation for the available options.

Thread ids also let you audit workflow history. Each state in the thread's history corresponds to a node completion. You can walk the history to understand exactly what happened at each step, which values were in state, and which transitions were taken.

Interrupt points for human review

LangGraph supports interrupts: points where the graph pauses execution and waits for an external input before continuing. An interrupt before a node means the node will not run until a person provides the required input.

Use interrupts at any point where a person's decision should determine the next path. Before a node that sends an email, posts to an external service, or modifies a record, an interrupt gives the reviewer a chance to see the proposed action and approve or reject it.

• Place interrupts before irreversible actions: sends, writes, publishes.
• Place interrupts when model confidence is below a threshold: let the graph surface the uncertainty to a person rather than proceeding.
• Place interrupts at natural review points: the end of a draft phase before an implementation phase begins.

Handling decisions at interrupt points

When a person reviews and approves at an interrupt, record the decision in a durable store before resuming the graph. The graph state holds the approval as a field for this run. The durable record holds the reason and the person who decided, available to every future run.

When a person rejects, record that too: what was rejected, what was wrong with it, and what the person wants instead. A rejection is as useful as an approval when it is recorded with enough context for the next attempt.

Keep the graph state and the decision record separate. The graph state is volatile: it is the working memory of this run. The decision record is durable: it persists across runs and sessions. A decision that lives only in the graph state is lost when the run ends.

Testing a LangGraph workflow

Test each node as a pure function: given a fixed state input, does it return the expected state update? These tests are fast and catch state schema errors early.

Test transitions next: given a completed node output, does the graph route to the right next node? Conditional edges are the most important to test — they encode the branching logic that determines the workflow's behavior under different conditions.

For interrupt behavior, test that the graph pauses at the right node and resumes correctly after an external input is provided. The AI agent approval workflow guide covers the full human review pattern.

How to do this with fenbs

1. Create a free account and model your LangGraph workflow as a project in fenbs. Each major phase maps to a task with its state requirements and interrupt conditions.
2. Write the approved rules in Decisions and rules: which nodes need human review, what the interrupt criteria are, which actions are pre-approved. Connect your AI assistant from Integrations so it reads these before each run.
3. When a graph interrupt produces a human decision, record it in fenbs as a decision with the reason. The next run reads it from fenbs rather than re-presenting the same choice.
4. Before the run ends, have the agent update the task with what was completed and where the next run should start. Use Where we left off so the next session starts from the correct state.
5. After a run that revealed a design gap, record a lesson in fenbs. The next assistant working on a similar graph will read it before starting.

fenbs holds the human decisions and project record alongside the graph, not inside it. The graph manages execution; fenbs manages the approved rules and what was agreed.