LangGraph, Strands, AgentCore — and the Patterns That Actually Matter in 2026
A practitioner's guide to choosing agentic orchestration frameworks and the design patterns behind them — with a sharp focus on AWS- native production deployment.
10 min read · April 2026 · Python · AWS · Bedrock
We're at the Microservices Moment for AI
The Landscape
In the early days of cloud architecture, teams built monolithic applications and eventually learned — sometimes painfully — that decomposing them into services was the right long-term bet. Agentic AI is going through exactly the same transition right now. Single all-purpose agents are giving way to orchestrated systems of specialized agents.
Gartner measured a 1,445% surge in enterprise multi-agent system inquiries from Q1 2024 to Q2 2025 (Gartner, December 2025). By end of 2026, 40% of enterprise applications are projected to embed AI agents — up from less than 5% in 2025. The frameworks and patterns you pick today will define your architectural ceiling for years.
The hard truth: Gartner predicts over 40% of agentic AI projects will be canceled by end of 2027 due to escalating costs and inadequate risk controls. The failures originate not in bad models, but in bad orchestration design — agents that are individually capable, but poorly coordinated, still fail. Framework choice is a first-class architectural decision.
This post cuts through the noise and maps the major frameworks to the patterns they serve best — with practical guidance for teams building on AWS.
The Real Contenders in 2026
The Frameworks
The field has consolidated. LangChain is partially deprecated as a primary agent runtime — its latest versions actually run on LangGraph under the hood. The meaningful choices today are:
| Framework | Philosophy | Best For |
|---|---|---|
| LangGraph | You design the graph, model executes it | Deterministic, auditable, stateful workflows |
| AWS Strands | Model decides the graph, you provide tools | AWS-native PoCs, AgentCore deployment, fast iteration |
| Bedrock AgentCore | Managed runtime platform (not a framework) | Hosting, governance, identity, memory for any framework |
| Agent Squad | AWS routing library for multi-agent scale | When Strands outgrows a single-orchestrator topology |
The core mental model: "LangGraph says: you design the graph, the model executes it. Strands says: you give the model tools and let it figure out the graph itself."
The axis isn't quality — it's developer control vs. model autonomy. Both are valid production choices. The wrong choice is picking one based on hype rather than your workflow's actual requirements.
Bedrock AgentCore: The Shift That Changes Everything
Platform Layer
The most important thing to understand about AgentCore is that it represents a categorical shift in what AWS is offering. Amazon Bedrock is no longer just a model hosting service. It is now the control plane, governance layer, and runtime that makes autonomous AI deployable in organizations with real risk profiles.
AgentCore reached general availability in October 2025 and works with any open-source framework — LangGraph, Strands, CrewAI, LlamaIndex, OpenAI Agents SDK — and any foundation model inside or outside Bedrock.
AgentCore Service Map
| Service | What It Does | Why It Matters |
|---|---|---|
| Runtime | Serverless execution, 8-hour long-running tasks, session isolation, bidirectional streaming | Eliminates infra management; handles multi-step workflows that outlive a single HTTP response |
| Memory | Session + long-term episodic memory; agents learn from prior interactions | Enables multi-day workflows; agents remember what failed and what worked |
| Gateway | Converts APIs to MCP-compatible tools; intercepts tool calls for policy enforcement | MCP-first architecture; bridges legacy APIs without rebuilding them |
| Identity | Cognito, Entra ID, Okta integration; OAuth vault; multi-tenant custom claims | Agents act on behalf of users or autonomously with proper IAM |
| Policy ✅ GA | Real-time tool call interception using natural language or Cedar policies | Enforces compliance boundaries without custom guardrail code |
| Evaluations ✅ GA | 13 pre-built evaluators; continuous CloudWatch monitoring | Shifts agent quality from manual spot-checks to a full DevOps lifecycle |
| Observability | Step-by-step execution visualization; OTEL-compatible; integrates with Langfuse, Datadog, Arize | Production-grade tracing; regulated industries can audit every step |
🔒 For regulated industries: AgentCore Policy uses Cedar — AWS's open-source policy language — to intercept every tool call in real time. Natural language policy definitions auto-convert to Cedar, making compliance boundaries auditable by non-engineers. Policy and Evaluations both reached GA in March 2026.
The 6 Orchestration Patterns You Need to Know
The Architecture
Frameworks are implementation tools. Patterns are the architecture. Production systems almost always combine two or three of these. Understanding them is what separates teams that ship from teams that stay in pilot purgatory.
1. Supervisor / Hierarchical
A central orchestrator decomposes the task, delegates to specialist sub-agents, validates outputs, and synthesizes a final result. The gold standard for most enterprise workflows. Gartner predicts that by 2027, 70% of multi-agent systems will use narrowly specialized agents, improving accuracy but increasing coordination complexity (Gartner, December 2025).
Use an expensive, capable model for the orchestrator; use cheaper, specialized models for each sub-agent.
Best implemented with: LangGraph (explicit state) or Strands + Agent Squad (model-driven routing)
2. Sequential Pipeline
Agent A hands off to Agent B. Classic for linear data transformation, document processing, or any workflow with clear stage dependencies.
Simple to debug, predictable cost profile. Critical rule: every stage must validate its inputs. Never pass garbage forward — a leaky pipeline where Stage 3 produces malformed output will have Stage 4 and 5 confidently processing garbage.
Best implemented with: LangGraph nodes with explicit state contracts
3. Parallel Fan-Out / Fan-In
Multiple agents work the same task simultaneously from different angles or specializations. A collector agent synthesizes results. Also called scatter-gather or map-reduce.
Cut latency on complex research, multi-perspective analysis, or consensus-building tasks. The initiator agent distributes work; the collector waits for all branches and produces a unified output.
Best implemented with: LangGraph parallel branches or Strands with concurrent tool calls
4. Choreography (Event-Driven)
Agents coordinate through events on a message bus — no central orchestrator. Agent A publishes research_completed, Agent B subscribes and acts, Agent B publishes analysis_ready, and so on.
High autonomy, loosely coupled, easy to add or remove agents. Trade-off: debugging is significantly harder without a centralized control flow. Best for workflows that change frequently, not for high-stakes deterministic pipelines.
Best implemented with: EventBridge + SQS + Lambda, or Kafka for higher throughput
5. Evaluator-Optimizer Loop (Reflection)
A generator agent produces output; an evaluator agent critiques it; the generator revises. The cycle repeats until a quality threshold is met.
Reflection is the most powerful pattern for accuracy-critical tasks — regulatory document authoring, code generation, clinical report drafting. Each critique round is a separate LLM call, so cost and latency multiply. Design your termination condition carefully.
Best implemented with: LangGraph cycles with conditional edges
6. ReAct (Reason + Act)
The foundational single-agent loop: Thought → Action → Observation → repeat. The model articulates its reasoning, calls a tool, observes the result, and decides the next step.
This is the basis for both Strands (which wraps this loop automatically) and most LangGraph nodes. Understanding ReAct is prerequisite to understanding every other pattern.
Best implemented with: Strands (native), LangGraph nodes, or any framework's AgentExecutor
⚡ The cascading hallucination problem: Agent A hallucinates a policy. Agent B executes against that hallucination. Agent C reports confidently on a corrupt baseline. Multi-agent systems amplify errors as much as they amplify capability. Use immutable state snapshots — each agent works with a versioned state object and produces a new version. This provides audit lineage, prevents accidental mutations, and makes replay possible.
How to Choose
Decision Framework
| Question | If YES | If NO |
|---|---|---|
| Does your workflow require auditable, deterministic step execution? (GxP, regulated, financial) | → LangGraph. Design the graph explicitly. Every transition is documented. | ↓ Continue |
| Are you AWS-native and targeting Bedrock / AgentCore for deployment? | → Strands Agents. Native AgentCore deployment, MCP-first tooling, built-in OTEL. | ↓ Continue |
| Do you have many specialist sub-agents needing routing and context isolation? | → Strands + Agent Squad for model-driven routing, or LangGraph for complex shared-state graphs. | ↓ Continue |
| Is this 2–4 agents with a clear, simple workflow? | → You may not need a framework. A 150-line orchestrator with explicit handoffs is easier to debug. | ↓ Continue |
| Rapid prototype, role-based team-of-agents, not AWS-specific? | → CrewAI. Fastest time to prototype for role-based multi-agent patterns. | — |
The Production-Ready AWS Stack
Recommended Stack
For complex, regulated, or enterprise-grade deployments on AWS, these layers complement each other without overlap:
| Layer | Role | Description |
|---|---|---|
| LangGraph | Deterministic | Sub-workflows requiring validated, auditable steps (GxP-adjacent processes, sequential with contracts) |
| AWS Strands Agents | Model-Driven | Primary agent loop — reasoning, tool calls, MCP tool integration |
| Agent Squad | Routing | Routing across specialist agents at scale |
| Bedrock AgentCore | Platform | Runtime · Memory · Identity · Policy · Evaluations · Observability — the foundation for all of the above |
🔭 Observability note: AgentCore Observability is OTEL-compatible and integrates natively with Langfuse. For regulated environments — pharma, healthcare, financial services — self-hosted Langfuse on AWS gives you full trace ownership with zero data leaving your VPC. This combination is current best-in-class for GxP-adjacent AI workloads.
What to Actually Do
Bottom Line
The teams winning in 2026 make a deliberate pattern choice early, instrument observability from day one, and resist the temptation to add more agents when better tools or prompts would solve the problem.
For most AWS practitioners: Start with Strands + AgentCore for speed and native integration. Add LangGraph for any sub-workflow where step auditability or strict ordering is non-negotiable. Wire Agent Squad in when your single-orchestrator topology starts to strain.
For regulated industries: AgentCore Policy (now GA) gives you Cedar-based tool call interception that compliance teams can read and audit without engineering involvement. AgentCore Evaluations (also now GA) gives you continuous quality monitoring rather than manual spot-checks. These two features alone move the "can we trust this in production?" conversation forward by months.
🧵 The sustainable pattern: The ability to leverage the reasoning capabilities of these models, coupled with the ability to do real-world things through tools, is a durable architectural bet. The specific frameworks will keep evolving. The pattern of reasoning + tool use + governance will not.
Agentic AI Architecture Guide · April 2026 · AWS · LangGraph · Strands · AgentCore
