Free tools Windows power users keep installed
One-click scans. No signup required.
How do I build a multi-agent system with LangGraph? Model the application as a graph whose state, routing, persistence and pause points you define. LangGraph provides orchestration infrastructure; it does not choose the right agents or decide what information they should share. The LangGraph reference maintained by LangChain describes it as “a low-level orchestration framework for building, managing, and deploying long-running, stateful agents.”
Should you use a supervisor or let agents hand off work? Use a supervisor when one component should own task decomposition and routing. Consider handoffs when responsibility may move between agents as work develops. In either design, deliberately set state boundaries, recovery behavior and human review points.
What does LangGraph handle—and what remains your job?
LangGraph gives an application an explicit graph for coordinating model calls, tools and other steps. Its documented capabilities include graph state and control flow, persistence, streaming and human-in-the-loop mechanisms. The application team still decides which agents exist, what each can do, how routing works, which state crosses a boundary and what happens when a step fails.
That distinction matters: adding a supervisor or a handoff mechanism does not by itself make delegation correct, specialist outputs reliable or the system cheaper. Those outcomes depend on the models, prompts, tools, state design and evaluation in your application.
Choose the level of abstraction deliberately
LangGraph’s official positioning emphasizes customization and explicit control for combinations of deterministic and agentic workflows. LangChain’s prebuilt agent architectures are positioned as a quicker setup when their constraints fit the application. A lower-level graph can be appropriate when the team needs control over routing, state transitions or workflow behavior, but that control brings implementation and maintenance work.
For a simple workflow that already fits a prebuilt architecture, building a custom graph may add unnecessary decisions. Conversely, if routing, recovery or review must follow application-specific rules, an explicit graph can make those rules easier to represent and inspect.
How do supervisor and handoff designs differ?
The key distinction is who chooses the next agent and what information travels between agents. A supervisor centralizes the routing decision; a handoff design lets a worker yield control. Neither pattern is inherently more accurate, faster or cheaper.
| Design | Who chooses the next agent? | What crosses the transition? | Useful when | Main design burden |
|---|---|---|---|---|
| Supervisor | A central supervisor selects a specialist and controls communication flow. | Define whether the parent receives a worker’s last answer or fuller output history; the supervisor reference documents output-history modes. | One component should decompose the task and own routing decisions. | The central decision point must choose appropriate workers and pass them useful context. |
| Handoff or swarm-style routing | A worker can yield control to another agent through a tool-based handoff. | The LangGraph swarm package says subagent state updates are applied to the parent graph state by default during handoff. | Responsibility may move among agents as the task develops. | Decide which state to retain or propagate, including whether history is too large or sensitive to share. |
| Custom graph or subgraphs | The graph’s explicit routing logic determines the next step; a subgraph can encapsulate a specialist workflow. | State visibility across graph boundaries must be designed. A subgraph may have its own checkpoint namespace. | Workflow boundaries, deterministic steps or recovery behavior need explicit control. | The team defines and maintains more of the workflow behavior. |
When a supervisor is a good fit
A supervisor is a natural starting point when there is a clear owner for breaking down requests and selecting specialists. In a hierarchical design, the supervisor can coordinate specialized agents; the official JavaScript supervisor reference also describes composing multiple supervisor levels. More levels can represent nested responsibilities, but they also mean more routing decisions and boundaries for the application to define.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Specify what the parent sees after a worker finishes. A last-answer-only view and a fuller history are different context policies, not interchangeable implementation details. Choose based on what the supervisor needs for its next decision, and avoid passing history that is unnecessary for that decision.
When handoffs are a good fit
Tool-based handoffs suit workflows where the agent doing the current work may recognize that another agent should take over. The swarm package’s default state propagation can help preserve continuity, but it also means the transition may carry more than a narrow result. Inspect the state being passed, especially conversation history and any sensitive or bulky fields.
“Swarm” describes a routing style, not a guarantee of unrestricted autonomy or a universal improvement over centralized routing. Keep authority over consequential actions, data access and stopping conditions in the application’s design.
How should state, subgraphs and persistence be scoped?
Treat state scope as an architectural choice. A worker needs enough information to do its assigned job, but sharing all conversation history or application data by default can make context harder to manage and expose information unnecessarily. Specify what each worker receives, what it returns, and whether its updates become visible to a parent or another worker.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Keep thread checkpoints distinct from cross-thread memory
LangGraph documentation distinguishes a checkpointer from a store. A checkpointer records graph-state snapshots associated with a thread, enabling continuity, interruption, time travel and recovery. A store holds application-defined information across threads, such as durable facts or preferences. Thread-local conversation state is not the same thing as cross-user or cross-session memory.
For subgraphs, do not assume the parent immediately sees every update. The persistence documentation describes subgraphs with their own checkpoint namespaces and identifies shared Store state or writing to the parent checkpoint as ways to make cross-boundary data available. Choose the mechanism to match the data’s intended scope.
Choose a durable checkpoint backend and a retention policy
In-memory savers such as MemorySaver or InMemorySaver keep checkpoints in RAM and lose them when the process restarts. The persistence documentation identifies SQLite and PostgreSQL as persistent checkpoint backends. Durable storage also creates a lifecycle responsibility: checkpoints can accumulate, so define pruning or retention rather than allowing storage to grow without a policy.
When invoking a graph that uses thread-scoped persistence, pass the same thread_id when you intend to continue that thread. The JavaScript PostgresSaver guide specifies a maximum thread ID length of 255 characters; a short stable identifier or a hash can help avoid exceeding it.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Understand what recovery does—and does not—promise
LangGraph’s persistence documentation says successful nodes’ pending writes may be preserved when another node fails, allowing resumption without rerunning completed work. That is a checkpointing recovery behavior, not a blanket exactly-once guarantee for external side effects. If a node charges a card, sends a message or changes another system, design that operation for retries and partial failure using the protections appropriate to that system.
A shared store can make durable information available across threads. Before putting user data there, define tenancy and authorization in the application; cross-thread availability does not itself establish who should be allowed to read or change a record.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.How do interrupts enable human review?
An interrupt pauses graph execution to request external input. The interrupt guide describes the state being saved while the run waits; the caller resumes by invoking the graph with a Command carrying the resume value. This creates a point where a person or another external process can review, edit or supply information before execution continues.
Place review before the actions that warrant it
The tool-call review guide describes three interactions: approve and continue, modify a proposed call manually, or give the agent natural-language feedback. Use an interrupt where the consequences of proceeding justify a person’s attention—for example, before a consequential tool action or when required input needs validation.
Recommended Free Tools
Design the review interface around the interrupt payload: show what is being proposed, what decision is needed and how the result will be resumed. An interrupt is a control-flow mechanism, not a safety policy. The application must still enforce permissions, validate inputs and constrain what the resumed graph can do.
How should you stream and inspect nested work?
Streaming can expose graph progress, while tracing or debugging streams can help developers inspect agent and tool activity. Decide which events belong in the user interface instead of forwarding every internal event; nested work may include details that users do not need or should not see.
The official streaming guide documents graph stream modes and nested subgraph streaming. Namespaces can identify which subgraph emitted a message, helping distinguish parent activity from nested work during inspection. The guide also describes a typed-projection event-streaming API introduced in LangGraph v1.2 and recommends it for new applications on that documentation page. Because this is a version-sensitive recommendation, check the installed LangGraph version and its current documentation before choosing an API.
Streaming and observability make activity visible; they do not, by themselves, improve model quality or reduce latency. Use development traces to find routing, tool or state problems, and expose only the progress information that helps the user understand what the application is doing.
How should you choose and evaluate a pattern?
Compare the designs against the workflow you actually need to run, not a claim that one pattern is universally best. The official materials describe capabilities and architecture but do not provide an apples-to-apples benchmark of supervisor, swarm and custom-graph implementations for latency, cost or accuracy.
- Routing ownership: Decide whether one supervisor selects workers or workers can hand off control.
- State boundary: Define the history and structured fields each worker receives and returns, and whether subgraph updates reach the parent.
- Persistence and recovery: Set thread checkpoint behavior, cross-thread store scope, backend durability and retention.
- Human control: Identify where execution pauses and what a reviewer can approve, edit or provide.
- Observability: Choose which parent and subgraph events to stream, and how developers will distinguish their origins.
- Implementation burden: Balance the control of a low-level graph against the workflow behavior a prebuilt architecture already supplies.
Test representative tasks from your own application with the same evaluation criteria across candidate designs. Include failure and recovery cases, state growth, review requirements and the effects of passing more or less history. Measure latency, cost and task quality in that workload rather than inferring them from the pattern name.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
