LangGraph Workflow Patterns

Comprehensive patterns for building production LangGraph workflows. Each category has individual rule files in rules/ loaded on-demand.

Quick Reference

Total: 32 rules across 10 categories

State Management

State schemas determine how data flows between nodes. Wrong schemas cause silent data loss.

Routing & Branching

Control flow between nodes. Always include END fallback to prevent hangs.

Parallel Execution

Run independent nodes concurrently. Use Annotated[list, add] to accumulate results.

Supervisor Patterns

Central coordinator routes to specialized workers. Workers return to supervisor.

Tool Calling

Integrate function calling into LangGraph agents. Keep tools under 10 per agent.

Checkpointing

Persist workflow state for recovery and debugging.

Human-in-Loop

Pause workflows for human intervention. Requires checkpointer for state persistence.

Streaming

Real-time updates and progress tracking for workflows.

Subgraphs

Compose modular, reusable workflow components with nested graphs.

Functional API

Build workflows using @entrypoint and @task decorators instead of explicit graph construction.

Quick Start Example

from langgraph.graph import StateGraph, START, END
from langgraph.types import Command
from typing import TypedDict, Annotated, Literal
from operator import add

class State(TypedDict):
    input: str
    results: Annotated[list[str], add]

def supervisor(state) -> Command[Literal["worker", END]]:
    if not state.get("results"):
        return Command(update={"input": state["input"]}, goto="worker")
    return Command(goto=END)

def worker(state) -> dict:
    return {"results": [f"Processed: {state['input']}"]}

graph = StateGraph(State)
graph.add_node("supervisor", supervisor)
graph.add_node("worker", worker)
graph.add_edge(START, "supervisor")
graph.add_edge("worker", "supervisor")
app = graph.compile()

2026 Key Patterns

• Command API: Use Command(update=..., goto=...) when updating state AND routing together
• context_schema: Pass runtime config (temperature, provider) without polluting state
• CachePolicy: Cache expensive node results with TTL via InMemoryCache
• RemainingSteps: Proactively handle recursion limits
• Store: Cross-thread memory separate from Checkpointer (thread-scoped)
• interrupt(): Dynamic interrupts inside node logic (replaces interrupt_before for conditional cases)
• add_edge(START, node): Not set_entry_point() (deprecated)

Key Decisions

Common Mistakes

1. Forgetting add reducer (overwrites instead of accumulates)
2. Mutating state in place (breaks checkpointing)
3. No END fallback in routing (workflow hangs)
4. Infinite retry loops (no max counter)
5. Side effects in router functions
6. Too many tools per agent (context overflow)
7. Raising exceptions in tools (crashes agent loop)
8. No checkpointer in production (lose progress on crash)
9. Wrapping interrupt() in try/except (breaks the mechanism)
10. Not transforming state at subgraph boundaries
11. Forgetting .result() on Functional API tasks
12. Using set_entry_point() (deprecated, use add_edge(START, ...))

Evaluations

See test-cases.json for consolidated test cases across all categories.

Related Skills

• agent-orchestration - Higher-level multi-agent coordination, ReAct loop patterns, and framework comparisons
• temporal-io - Durable execution alternative
• llm-integration - General LLM function calling
• type-safety-validation - Pydantic model patterns