LangGraph lets you compile a StateGraph and then use it as a single node inside a parent graph (a subgraph). Describe two concrete scenarios where reaching for a subgraph beats inlining the same nodes in the parent graph, and one scenario where it does not.
Free · 2 AI evals / day
**LangGraph subgraphs** let you compile a `StateGraph` and then use it as a single node inside a parent graph. The parent treats the subgraph as a Runnable: it sends in some state, the subgraph runs internally, and returns an update.
There are three patterns where this is clearly worth it.
First, **reusable specialist flows**. A retrieve and rerank pipeline you want to call from both a chat agent and a batch summarizer. Build it once as a subgraph, mount it in both parents. Updating the rerank logic now means changing one definition, not two.
Second, **supervisor / multi-agent patterns**. A supervisor graph has one node per specialist agent (researcher, writer, critic). Each specialist is itself a graph with its own state and internal loop. Inlining all the specialists' nodes into the supervisor would explode the node count and force everyone to share one giant state schema.
Third, **state isolation**. A subgraph keeps its own internal state and exposes only a small mapped surface to the parent. The parent never sees the subgraph's scratch reasoning or intermediate retrieval candidates.
Where subgraphs are NOT worth it: a flow called from one place with three nodes and no state isolation. Wrapping it adds a compile step, makes checkpoints coarser, and gives nothing back.
**LangGraph subgraphs** are compiled `StateGraph`s used as single nodes inside parent graphs. They earn their keep in three patterns and waste effort in one.
**Reuse across parents.** A retrieve rerank deduplicate flow needs to run from a chat agent and from a nightly batch summarizer. Build it once as a subgraph, mount the same compiled graph in both parents. The alternative, copying the nodes into both, duplicates logic and drifts over time.
**Supervisor / multi-agent composition.** A supervisor graph routes among specialist agents (researcher, writer, critic). Each specialist is naturally its own graph: it has its own internal loop, its own tools, its own state schema. Modeling all specialists as inline nodes forces a single shared state and explodes the parent's node count. Modeling each as a subgraph keeps the supervisor lean and lets each specialist evolve independently.
**State isolation.** A subgraph keeps its own state schema, with reducers and fields the parent does not need to know about. Map only the small surface that matters ("return the final answer and a confidence score") into the parent state. This is cleaner than dragging every intermediate field, retrieval candidates, scratch reasoning, tool-call traces, into the parent's top-level state.
**Where inlining wins.** A linear flow called from exactly one parent, with five or fewer nodes, no internal loop, no state worth hiding. Wrapping it as a subgraph adds a compile step, coarsens the checkpoint granularity (checkpoints land at the parent's subgraph-call boundary by default), and complicates time-travel debugging without any structural payoff.
**The senior framing.** Subgraphs are a unit of encapsulation. Reach for them when encapsulation buys you reuse, supervisor structure, or state hiding. Inline everything else.
Quick reference
TL;DR
Subgraphs earn their keep for reusable specialist flows, supervisor multi-agent patterns, and internal state isolation; inline a flow used in one place with no state hiding needed.
Picture a kitchen. A subgraph is like having a separate pastry station with its own counters, tools, and recipes. The head chef just says "give me a tart" and doesn't need to know how the pastry station works internally. That setup is great if multiple dishes need pastry or if the station genuinely has its own workflow. But if you only ever make one tart a year and the recipe is three steps, hauling out the whole pastry station is overkill, just bake it on the main counter. Same idea with subgraphs: powerful when you need reuse or isolation, overhead when you don't.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
A linear flow called from exactly one parent, with a handful of nodes and no state worth hiding. Wrapping it as a subgraph adds an extra compile and coarsens checkpoint granularity for zero reuse or isolation payoff.
A small graph where the team needs fine-grained time-travel debugging across every step. By default the parent treats the subgraph as one node, so checkpoints land at the boundary. Step-level rewind inside the subgraph needs explicit `subgraphs=True` plumbing.
Hot-path code where compile overhead matters and the graph definition isn't truly reused. Every subgraph compiles separately. Many small subgraphs add up at startup or at hot-reload time in dev. Inline when the encapsulation benefit isn't real.
Quick scan · 2–4 min
Everything important, quickly.
Name the three earn-keep scenarios (reuse, supervisor, state isolation), give the inline-wins scenario, walk the input/output schema mechanism for state isolation, mention checkpoint granularity and compile cost as real tradeoffs, and close with the encapsulation framing.
Real-world examples
Real products, models, and research that use this idea.
1LangGraph's official multi-agent supervisor template uses one subgraph per specialist (researcher, coder, critic), with the supervisor routing among them.
2Replit's Agent uses subgraphs to encapsulate IDE-specific tool sequences so they can run identically from chat and from CI hooks.
3Anthropic's Claude Code agent architecture (graph-based, gated tool calls) is structurally similar: tool-execution loops are encapsulated so the orchestrator graph stays small.
4Open-source projects like crewai-flows and langgraph-supervisor demonstrate the supervisor + subgraph pattern as the standard production multi-agent shape.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QWalk through how to set up step-level checkpointing inside a subgraph.
Sign in or go Pro to see the approach for this follow-up.
QHow do input-state and output-state schemas work on the subgraph boundary?
Sign in or go Pro to see the approach for this follow-up.
QYou have three specialist agents (researcher, writer, critic) and a supervisor. Walk through whether they should all share one state schema or each have their own.
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Reaching for a subgraph because "composition is good". The subgraph only earns its keep with reuse, supervisor patterns, or internal state that should stay hidden.