The map, for someone who already calls the API by hand

Two names, one stack. As of their v1.0 releases on 22 October 2025, LangChain and LangGraph are no longer competitors or even really separate tools — they're two altitudes of the same thing.³ Get that relationship straight first; everything else hangs off it.

Start from what you already do

When you build an agent against the raw API today, you hand-write a loop. It looks like this, in spirit:

# the loop you already write by hand
messages = [user_msg]
while True:
    resp = client.messages.create(model=..., tools=tools, messages=messages)
    if resp.stop_reason != "tool_use":
        break                          # model gave a final answer
    for call in tool_calls(resp):
        result = run_tool(call)            # you dispatch + execute
        messages.append(tool_result(result))
    messages.append(resp)                  # feed it all back, loop again

LangChain's headline abstraction, create_agent, is that loop — standardized. The docs describe it in exactly three steps: send a request to the model with tools and prompt; the model returns either tool calls (execute them, add the results) or a final answer; repeat until done.³ So the first honest answer to "what does it add?" is: it deletes the boilerplate loop you keep rewriting — and standardizes the messy parts around it.

So when do you ever touch LangGraph?

The hand-written loop above has a hidden ceiling. It's a straight line: call model → run tools → repeat. The moment you want structure — branch here, loop back there, run two things in parallel, pause for a human, survive a crash and resume — you start hand-rolling a state machine. LangGraph is that state machine, done properly.

The LangGraph mental model — enough to read one

Your mission is reading fluency: open someone's StateGraph and narrate what it does. You only need four nouns. The docs put the whole thing in five words: "nodes do the work, edges tell what to do next."¹

Under the hood it's message passing in the style of Google's Pregel system: execution runs in discrete super-steps where active nodes run (in parallel if more than one is active), pass messages along edges, and go inactive. When no node is active and no message is in flight, the graph stops.¹ You rarely need this detail to read a graph — but it's why parallel branches and loops "just work."

from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from typing import Annotated, TypedDict

class State(TypedDict):
    messages: Annotated[list, add_messages]     # reducer = append, not overwrite

def call_model(state):
    return {"messages": [llm.invoke(state["messages"])]}

def route(state):
    last = state["messages"][-1]
    return "tools" if last.tool_calls else END   # the branch

g = StateGraph(State)
g.add_node("model", call_model)
g.add_node("tools", tool_node)
g.add_edge(START, "model")
g.add_conditional_edges("model", route)   # model → tools, or → END
g.add_edge("tools", "model")            # tools loop back to model
agent = g.compile()