LangChain LangGraph Workflows: Stateful Agents, Nodes, Edges and Human Review

When Graphs Beat Chains

Some AI workflows are more than a simple chain. They branch, retry, ask for human approval, call tools, revise outputs, and carry state across steps. LangGraph is the pattern used when an LLM application needs explicit workflow control instead of a loose agent loop.

The main idea is simple: define state, define nodes that update state, then connect nodes with edges. The graph makes control flow visible, testable, and safer than hiding all decisions inside one prompt.

A chain is excellent when every request follows the same sequence. A graph is better when the workflow can branch: retrieve documents, decide whether evidence is enough, ask a human reviewer, call a tool, revise the answer, or stop with a refusal.

Represent state as a typed dictionary or model.
Keep nodes small: retrieve, grade, answer, review, or finalize.
Use conditional edges for decisions such as retry, escalate, or finish.
Log state transitions for debugging and auditability.

Human-in-the-Loop Design

For risky workflows, the graph can pause before an irreversible action. The model may draft a refund, ticket update, or email, but a person approves before the system commits the action.

Require approval for writes, payments, deletions, and external messages.
Show the human reviewer the model output, evidence, tool arguments, and confidence signals.
Make rejection and revision part of the workflow, not an exception.

Graph State and Nodes

This pseudocode-style example shows the shape of a controlled workflow.

Graph State and Nodes

from typing import TypedDict

class SupportState(TypedDict):
    question: str
    documents: list
    answer: str
    needs_review: bool

def retrieve(state: SupportState):
    docs = retriever.invoke(state["question"])
    return {"documents": docs}

def answer(state: SupportState):
    response = rag_chain.invoke({
        "question": state["question"],
        "documents": state["documents"],
    })
    return {"answer": response}

def grade_risk(state: SupportState):
    risky = any(word in state["answer"].lower() for word in ["refund", "legal", "delete"])
    return {"needs_review": risky}

Each node accepts state and returns only the updates it owns.
This pattern is easier to test than one giant function that does everything.

Apply a Deterministic State Transition Before the Next Node

def review_node(state):
    attempts = state.get('attempts', 0) + 1
    approved = state.get('score', 0) >= 0.8
    return {**state, 'attempts': attempts, 'approved': approved}

state = {'score': 0.86, 'attempts': 0}
print(review_node(state))

Output

{'score': 0.86, 'attempts': 1, 'approved': True}

Before you move on