LangGraph in 2026: Build a Support Agent That Knows When to Ask

1. The Problem: Demos Forget, Refunds Do Not

A support chatbot over a plain LLM call has three fatal flaws. It has no memory between requests, so every message starts from zero. It cannot act, so it can only talk about refunds instead of processing them. And it cannot escalate, so the risky decision — sending money back — happens with zero oversight or gets blocked entirely.

LangGraph solves this with an explicit graph: nodes do the work, edges decide what happens next, a checkpointer remembers the state per conversation thread, and an interrupt pauses execution until a human approves. That is the architecture we are about to build.

2. Minimum Concepts: State, Nodes, Edges, Checkpoints

LangGraph is a low-level orchestration framework: you define an agent as a graph instead of a chain. Four ideas carry 90% of the framework. Learn these and the tutorial below will read like plain Python.

3. Steps 1–2: Tools and State

Install the packages, define two support tools, and bind them to the model. The refund tool does not execute directly — it will be gated by the approval node later. State is a TypedDict with an appended message list plus one domain field.

pip install langgraph langchain-anthropic
export ANTHROPIC_API_KEY="sk-..."
export LANGSMITH_TRACING="true"   # flight recorder on

from langchain.tools import tool
from langchain.chat_models import init_chat_model

model = init_chat_model("claude-sonnet-4-6", temperature=0)

@tool
def lookup_order(order_id: str) -> str:
    """Look up an order by ID. Returns status and total."""
    return f"Order {order_id}: shipped, total $84.20"

@tool
def issue_refund(order_id: str, amount: float) -> str:
    """Issue a refund. Only runs after human approval."""
    return f"Refunded ${amount:.2f} to order {order_id}"

tools = [lookup_order, issue_refund]
model_with_tools = model.bind_tools(tools)

from typing_extensions import TypedDict, Annotated
from langchain_core.messages import AnyMessage
import operator

class SupportState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]
    customer_tier: str

4. Steps 3–4: Nodes, Edges, and the Graph

Two nodes (agent + prebuilt ToolNode), one routing function, four edges. The agent node calls the bound model; should_continue sends tool calls to execution and plain answers to END. Compile once without a checkpointer to test the loop, then add memory in the next step.

from langgraph.graph import StateGraph, START, END
from langgraph.prebuilt import ToolNode
from typing import Literal

def agent_node(state: SupportState):
    reply = model_with_tools.invoke(state["messages"])
    return {"messages": [reply]}

def should_continue(state: SupportState) -> Literal["tools", END]:
    if state["messages"][-1].tool_calls:
        return "tools"
    return END

builder = StateGraph(SupportState)
builder.add_node("agent", agent_node)
builder.add_node("tools", ToolNode(tools))
builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", should_continue, ["tools", END])
builder.add_edge("tools", "agent")

graph = builder.compile()  # memory comes next

from langchain_core.messages import HumanMessage
out = graph.invoke({
    "messages": [HumanMessage(content="Where is order 8821?")],
    "customer_tier": "pro",
})
print(out["messages"][-1].content)

5. Steps 5–6: Memory, Approval Gate, and Tracing

Now recompile with a checkpointer, insert the refund_approval node between tools and execution, and resume with Command. Refunds over $50 pause for a human; everything else flows through. LangSmith records both halves of the paused run automatically.

from langgraph.checkpoint.memory import InMemorySaver
from langgraph.types import interrupt, Command

def refund_approval(state: SupportState):
    last = state["messages"][-1]
    calls = [c for c in last.tool_calls if c["name"] == "issue_refund"]
    if not calls or calls[0]["args"].get("amount", 0) <= 50:
        return {"messages": []}  # small amounts pass through
    ok = interrupt({  # pauses here, payload shown to reviewer
        "question": "Approve this refund?",
        "order": calls[0]["args"],
        "tier": state["customer_tier"],
    })
    if not ok:
        return {"messages": [HumanMessage(content="Refund declined by reviewer.")]}
    return {"messages": []}

builder.add_node("refund_approval", refund_approval)
builder.add_edge("tools", "refund_approval")
# rewire: tools -> approval -> agent (rebuild + recompile)
checkpointer = InMemorySaver()  # SqliteSaver / PostgresSaver in prod
graph = builder.compile(checkpointer=checkpointer)

config = {"configurable": {"thread_id": "support-123"}}
first = graph.invoke(
    {"messages": [HumanMessage(content="Refund $340 to order 8821")],
     "customer_tier": "pro"},
    config=config,
)
print(first.get("__interrupt__"))  # paused, waiting for a human
final = graph.invoke(Command(resume=True), config=config)  # approve
print(final["messages"][-1].content)

6. Common Errors (and the One-Line Fix for Each)

These four failures account for most LangGraph support threads I have seen. Each has a precise cause and a one-line fix — memorize them before you ship.

7. When LangGraph Pays Off — and When It Does Not

LangGraph is overhead for single-shot prompts and a superpower for stateful workflows. Use this rule to decide before you commit a new graph to your codebase.

Sources

Every API in this tutorial is taken from the official docs and current community guides. Verify before you ship — frameworks move fast.

• LangGraph Quickstart (Graph API: StateGraph, ToolNode pattern, bind_tools)
• Interrupts: interrupt(), Command(resume=…), approval and review patterns
• Persistence: InMemorySaver, PostgresSaver, SqliteSaver, thread_id
• LangGraph overview: orchestration, durable execution, HITL
• Checkpointers: why thread_id is required, fault tolerance

Conclusion

You now have a support agent that remembers the conversation, looks up orders, and refuses to move money without a human saying yes. That loop — state, tools, checkpoint, interrupt, trace — is the template behind most production agents I build or rescue.

Next step: point the same graph at your own tools (Zendesk lookup, Stripe refund in test mode), swap InMemorySaver for PostgresSaver, and watch the first ten traces in LangSmith. The traces will teach you more than any tutorial — including this one.