02 Frameworks & Tools 2 min read 498 words
LangGraph Orchestration (Dec 2025)
LangGraph is the de facto standard for building stateful, multi-agent systems in late 2025. Unlike simple chains, LangGraph allows for Cycles, State Persistence, and Human-in-the-Loop interventions.
The Graph Philosophy
In 2023, agents were "Black Boxes." In 2025, agents are Graphs. A graph consists of:
- Nodes: Python functions (The LLM, a tool, or data processing).
- Edges: Paths between nodes.
- Conditional Edges: Logic that determines the path based on the State.
Cyclic vs. Acyclic
Standard LangChain is Acyclic (Sequential). LangGraph is Cyclic.
- The Power of the Loop: An agent can try a tool, see the error, and cycle back to the "Thinking" node to try again. This is the foundation of the ReAct pattern.
State Management
The State Schema is the "Mind" of the graph.
class GraphState(TypedDict):
messages: Annotated[list[AnyMessage], add_messages]
plan: list[str]
is_secure: bool
Nuance: Using Annotated with add_messages allows the graph to Append to history rather than overwriting it, preserving the full reasoning trajectory.
Persistence and Checkpointing
Late 2025 LangGraph uses Thread-based Persistence.
- The Concept: Every session has a
thread_id. - The Win: If a user comes back after 2 days, the agent remembers the exact point it was at in a multi-step workflow.
- Time-Travel: Developers can "re-run" a specific thread from a previous state to debug a failure.
Multi-Agent Patterns
| Pattern | Description | Case Study |
|---|---|---|
| Supervisor | One "Manager" directs specialized workers. | Research Team |
| Peer-to-Peer | Agents hand off tasks to each other directly. | Customer Support |
| Hierarchical | Graphs within Graphs (Nested graphs). | Enterprise Engineering |
Interview Questions
Q: Why use LangGraph instead of OpenAI's "Assistant API"?
Strong answer: Control and Portability. The Assistant API is a black box: you cannot see the exact prompts or control the logic gates. LangGraph is a White Box framework. I can use any model (OpenAI, Claude, Llama 3.3), control exactly when a tool is called, and inject my own custom validation logic between steps. More importantly, LangGraph is Open Source and can run locally/on-prem, which is critical for many enterprise security requirements.
Q: How do you handle "State Overload" in a graph with 20+ nodes?
Strong answer: We use State Narrowing. Instead of passing the entire global state to every node, we define specialized sub-states for sub-graphs. We also use Trim Runnables to prune the message history before it hits the LLM, ensuring we don't waste tokens while keeping the "Truth" preserved in the persistence layer.
References
- LangChain Team. "LangGraph: Multi-Agent Workflows at Scale" (2025)
- Anthropic. "Building Resilient Agents with State Machines" (2025)
- OpenSource AI. "Cycles and the Future of Agency" (2024 Tech Report)
Next: LangSmith Observability
Key takeaways
01
Cycles are the whole difference
A chain runs once and forward; a graph can send a failed tool call back to the thinking node, which is what makes the ReAct pattern expressible at all.
02
The state schema is the design
A typed dict of messages, plan and flags defines what nodes can see; annotating messages with add_messages appends to history instead of overwriting the reasoning trajectory.
03
thread_id buys resumption and time travel
Per-thread persistence lets a user return two days later mid-workflow, and lets a developer replay a thread from an earlier state to reproduce a failure.
04
Narrow the state before twenty nodes
Sub-graphs get specialized sub-states rather than the whole global object, and trim runnables prune message history before the LLM call while persistence keeps the full record.