Why LangGraph Changed How I Think About Agents

· 5 min read
LangGraph agents LLM

For a long time, I built agents using linear chains. Input → retrieve → reason → output. It worked for simple tasks, but fell apart as complexity grew.

LangGraph changed the architecture — and with it, how I reason about agents entirely.

The Problem with Linear Chains

A chain is a directed acyclic graph. Information flows one way. If something goes wrong mid-chain, your only option is to fail or retry the whole thing. There's no branching, no memory of prior states, no ability to loop back.

Real-world tasks don't work that way. A user asks a question, the agent retrieves context, determines it's insufficient, decides to search the web, gets conflicting information, needs to reconcile it — and at some point should ask a clarifying question rather than guess.

That's a graph, not a chain.

What LangGraph Provides

LangGraph builds on LangChain but adds three primitives that change everything:

  1. Stateful nodes. Each node in the graph receives and returns a typed state object. State persists across the entire graph execution.

  2. Conditional edges. After any node, you can route to different next nodes based on the current state. This enables dynamic control flow.

  3. Cycles. You can loop. An agent can check its work, decide it's not good enough, and try again — up to a configurable limit.

from langgraph.graph import StateGraph, END

workflow = StateGraph(AgentState)

workflow.add_node("retrieve", retrieve_context)
workflow.add_node("evaluate", evaluate_relevance)
workflow.add_node("answer", generate_answer)

workflow.add_conditional_edges(
    "evaluate",
    lambda state: "answer" if state["is_sufficient"] else "retrieve",
    {"answer": "answer", "retrieve": "retrieve"}
)

The Mental Model Shift

I stopped thinking "what sequence of steps do I need?" and started asking "what states can my agent be in, and how does it move between them?"

This framing unlocks things like: - Human-in-the-loop checkpoints (pause and wait for approval before taking an action) - Parallel branches (retrieve from multiple sources simultaneously) - Subgraphs (nested agents as reusable components)

Where I Use It Now

  • Research agents that iteratively refine their queries based on what they find
  • Document processing pipelines with conditional routing based on document type
  • Customer support flows that escalate to human review when confidence is low

The Trade-off

LangGraph agents are harder to debug than chains. A misbehaving chain fails loudly and linearly. A graph can get stuck in unexpected loops or take paths you didn't anticipate.

Invest in tracing (LangSmith is excellent here) before going to production. Observability is what makes complex graphs maintainable.

← Back to Writing