Strands vs LangGraph: choose by control, state, and recovery

Key takeaways

• Strands fits teams committed to AWS services.
• LangGraph fits complex workflows that need explicit control or multi-cloud flexibility.
• A hybrid can put workflow coordination in LangGraph and node-level reasoning in Strands.

The useful way to evaluate Strands vs LangGraph is to ask where control lives. Follow execution, durable state, intervention, recovery, telemetry, and deployment through the system. Then run the same small workflow in both frameworks under fixed conditions. That turns a broad framework preference into a set of operating boundaries your team can inspect.

Strands vs LangGraph at a glance

Both approaches can let a model select tools, so tool calling alone does not settle the choice. The differences become clearer when each operating concern is tied to its actual mechanism.

These are documented framework mechanisms, not a universal ranking. The right boundary depends on the workflow you must operate.

How should you compare the same workflow?

A fair comparison starts by implementing and tracing the same small task in both candidates. Freeze the task, model configuration, tools, environment, and completion criteria before you run either prototype.

Do you need either framework yet?

Possibly not. A single-model tool loop can be written in fewer than one hundred lines with a provider SDK, and that can be enough for a simple use case. That baseline is useful because it shows what the framework must add before you accept another layer in the harness.

A framework becomes useful when the application needs one or more of these capabilities:

• durable state;
• retries;
• multi-agent delegation;
• human-in-the-loop steps; or
• consistent tracing.

Treat those needs as the reason for adopting a framework, not as a generic feature wish list. If the small provider-SDK loop is sufficient, it remains a valid implementation. If the workflow needs persistent progress, repeatable recovery, delegated work, intervention, or common traces, the framework now has a clear job.

Before choosing, write down the requirement behind each capability. Name the state that must remain durable. Identify the work that needs retries and the work that would be delegated to another agent. Mark any step that needs a person in the loop. Finally, decide whether executions need one consistent tracing path. This short requirement list gives each framework mechanism something concrete to satisfy.

The baseline also puts a useful limit on the evaluation. You are not asking which library has the longest feature list. You are asking whether either candidate handles those five needs for the same small task better than the provider-SDK loop you could otherwise keep.

LangGraph can supply explicit orchestration when that job calls for it. At the same time, a graph does not have to be hand-coded for every LangChain agent. That distinction prevents an overly narrow comparison between a free-form agent loop and a manually drawn graph.

Our overview of AI agent frameworks can help place this choice within the broader framework landscape. Keep the smallest controllable architecture as the baseline, then add the mechanisms the workload actually requires.

Checkpoint and approval mechanisms differ by use case

State and intervention are where similar feature labels can hide different control boundaries. For new single-agent Strands sessions, SnapshotSessionManager provides immutable checkpoints and restore support. That is a specific session mechanism with a specific topology.

Strands also exposes invocation_state, but it lasts for one invocation. It is separate from persistent agent.state. Invocation-scoped configuration should therefore be treated as invocation-scoped configuration, not as durable session management. If a prototype relies on it, the trace and state inventory should make that boundary plain.

LangGraph provides explicit state management with checkpointing and interrupt support. Its documented pause-and-resume pattern can place human approval before an external action. This is a concrete control surface for workflows where an action should wait for a person.

The choice is not simply whether both frameworks mention state. Ask what must survive, what must be restored, and where execution must pause. A new single-agent Strands session can use immutable snapshots and restore support. A LangGraph workflow can use checkpoints and interrupts for approval before an external action. Those mechanisms solve different operating problems.

Write a small state contract for each prototype. It should name the data available during one invocation, the data expected to persist after that invocation, and the checkpoint used for restore or resume. For the LangGraph approval path, also mark the external action that follows the interrupt. For the Strands session, keep invocation_state separate from persistent agent.state in that contract.

This makes the comparison inspectable. A label such as "memory" or "state" is too broad to tell an operator what survives or where a person can intervene. The named mechanisms show which boundary each prototype is actually using.

For a focused implementation path, see our human-in-the-loop LangGraph example. In a prototype, inspect the saved state before the pause, the approval boundary itself, and the state used when execution resumes.

Deployment does not lock observability to one framework

Deployment and framework choice do not always move as one package. A Strands Agent can run through LangGraph's Functional API on LangSmith Deployment with LangSmith tracing. LangSmith Deployment can also run frameworks beyond LangGraph, including Strands, CrewAI, AutoGen, and Google ADK.

That cross-framework support changes the deployment question. A team can evaluate Strands as the agent implementation while still considering LangSmith Deployment and its tracing. The agent library, deployment surface, and observability path can be assessed as separate operating boundaries.

The reverse hosting question also stays open. AgentCore Runtime can host applications built with LangChain or Strands when the application fits its deployment contract. A compatible host remains an option for both approaches as well.

For each prototype, write down three selections: the agent implementation, the deployment environment, and the telemetry path. One supported combination is a Strands Agent through LangGraph's Functional API on LangSmith Deployment with LangSmith tracing. Another supported hosting option is a LangChain or Strands application on AgentCore Runtime when its contract fits.

That exercise keeps a hosting preference from silently deciding the agent library. It also exposes the exact combination the same-workflow test must run. If the production candidate uses managed deployment, test that candidate. If it uses a compatible host and a configured telemetry backend, test that combination instead.

The practical comparison is therefore not "LangGraph means one host and Strands means another." Map three choices independently: the mechanism that runs the agent, the environment that hosts it, and the path that carries its telemetry. Then test the combination you would actually operate.

The LangSmith deployment documentation provides the named Strands deployment path. Treat AgentCore Runtime's deployment contract as a real constraint, not a detail to assume away.

Which workload points to Strands or LangGraph?

For a team fully committed to AWS, Strands offers native Bedrock integration and built-in tools for S3, DynamoDB, and Lambda. LangGraph fits complex multi-step workflows that need explicit control, human-in-the-loop patterns, or multi-cloud flexibility. Those are workload fits, not universal verdicts. The comparison should still use the same task and the deployment combination your team expects to run. This framework comparison describes those boundaries directly.

When does a hybrid architecture make sense?

A hybrid makes sense when orchestration and node-level reasoning belong at different control boundaries. LangGraph and Strands can be combined in a multi-agent system deployed on AWS infrastructure. In the documented architecture, the two frameworks do not compete for the same job.

LangGraph manages macro-level agent coordination. It also manages state persistence and workflow recovery. Strands supplies the detailed reasoning engine inside individual workflow nodes. That division leaves the outer workflow legible while allowing a Strands Agent to do the reasoning work assigned to a node.

The boundary can be written as four responsibilities:

1. LangGraph coordinates the agents at the macro level.
2. LangGraph persists workflow state.
3. LangGraph owns workflow recovery.
4. Strands provides detailed reasoning inside a node.

This contract is more useful than calling the whole system a LangGraph application or a Strands application. It identifies which mechanism an operator should inspect when the workflow stops, state must be recovered, or a reasoning node needs its own trace.

The separation supports checkpoint-based recovery and comprehensive observability in that architecture. Combining model-agnostic Strands with LangGraph state management also provides a pattern for applications that require flexibility and reliability.

This is the core architectural insight: framework choice can happen at more than one layer. The outer harness can own coordination, persistence, and recovery. A node can own a bounded reasoning task. When those responsibilities are explicit, the system has a clear place to resume the workflow and a clear place to inspect the reasoning node.

Do not turn that documented design into a universal production recipe. Use it when the same split exists in your workload. In the prototype, identify the state that belongs to the outer workflow, the reasoning delegated to each node, and the traces needed across both. Then include a failed node attempt and a workflow recovery in the same-workflow comparison.

The hybrid also needs to earn its extra boundary. Compare it with each single-framework prototype under the same fixed conditions. The relevant question is whether separating macro coordination from node reasoning gives the workload the persistence, recovery, and observability mechanisms it requires.

AWS describes this exact LangGraph and Strands hybrid architecture. If the main design problem is coordination among several agents, our guide to multi-agent systems with LangGraph develops that part of the harness further.

What changes if you migrate?

A passing baseline does not show that state, approval, recovery, or handoff behavior survived the migration. Mark each checklist item as retained, replaced, or retired, and keep its test or trace with the result.

Apply that comparison to your two prototypes. For a deeper control-contract approach, read our guide to choosing an open-source agentic AI framework.