AWS Strands and the agent-framework wars

AWS shipped Strands a couple of weeks back, their open-source SDK for building agents on top of Bedrock and the broader AWS surface. It joins a crowded market: LangGraph from LangChain, Semantic Kernel from Microsoft, the OpenAI Agents SDK, the Anthropic Agents SDK, Google's ADK preview, plus AutoGen, CrewAI, Letta, and a long tail of others. The market is past the "we need a framework" phase and into the "which one wins" phase, and the answer is messier than the question suggests.

Worth being explicit about what Strands actually is, what differentiates the major players, and whether the framework layer is still where the architectural decisions get made.

What Strands is

The basics: Strands is a Python (and TypeScript, in preview) SDK for building agentic applications. It's open source, vendor-neutral on the model side (works with any model, not just Bedrock-hosted ones), and ships with first-class support for the AWS service surface. Lambda, DynamoDB, S3, Step Functions, the lot. The agent abstraction is reasonably standard: an agent has a model, a set of tools, a planning strategy, and an execution loop. The novel parts are mostly on the AWS-integration side rather than the agent-design side.

What it does well: integration with the AWS foundation is clean and well-thought-out. Deployment via Lambda or ECS is one config away. Observability hooks into CloudWatch. IAM-based scoping for tool access. If you're already on AWS and building an agentic application, Strands removes a lot of glue code that you'd otherwise write.

What it does less well: the cross-vendor story is functional but feels secondary. The non-AWS deployment path is supported but not loved. The pattern is the same one I noted with Bedrock more broadly. AWS is happy to support non-AWS use, but the rough edges accumulate the further you get from the home turf.

How the framework menu lines up

A side-by-side reading of the major players, as of early June:

LangGraph (LangChain). The most vendor-neutral of the bunch, the most flexible, and the most overwhelming for first-time users. The graph-based composition model is powerful and unwieldy. Best for teams that want maximum control over the agent's execution flow and are willing to pay the complexity tax.

Semantic Kernel (Microsoft). Tight integration with Azure and Microsoft 365. Cleaner abstraction than LangGraph, more opinionated, less flexible. Best for shops already living in the Microsoft world.

OpenAI Agents SDK. Newer entrant, optimized for OpenAI models with tool-use built around the Responses API. Cleanest abstraction in the list. Less flexible on the model side; great if you're an OpenAI shop.

Anthropic Agents SDK. Similar shape to the OpenAI one, optimized for Claude. The MCP integration is the strongest of any framework, agents can call out to any MCP server natively. Best for Claude-aligned shops, especially ones using the MCP ecosystem heavily.

AWS Strands. Vendor-neutral on models, vendor-locked on infrastructure. Best for teams running on AWS who want a clean agent SDK that fits the AWS foundation.

Google ADK (preview). Early. Tied to Vertex AI. The agentic surface looks reasonable; not enough production usage yet to assess.

The pattern is: each major model vendor (and AWS, despite not being a model vendor) shipped their own framework. Each one is best-in-class on its home foundation and varying degrees of clunky elsewhere. The cross-vendor neutral options (LangGraph, AutoGen, CrewAI) are flexible and complex.

The thing the keynotes won't tell you

Most production agentic systems I've seen this year that work well don't depend much on the framework. They use whichever SDK fits the foundation, with a thin abstraction layer between the application logic and the SDK that lets them swap. The differentiation isn't in the framework choice, it's in the design patterns layered on top of whatever SDK is underneath.

The framework matters at the margins. A team using LangGraph and a team using OpenAI Agents SDK to build similar agents will produce systems that look 90% the same to the end user, with the 10% difference mostly being which foundation they're locked to. The framework decision is a foundation-locking decision more than a capability decision.

The implication: don't agonize over the framework choice. Pick the one that fits your model and infrastructure preferences, build a thin abstraction so you can swap if needed, and spend the design energy on the patterns and the governance rather than the framework selection.

The interoperability story

The longer-term trend that matters more than any single framework: cross-framework interoperability via MCP. If your agent's tools are exposed as MCP servers rather than as framework-specific tool definitions, the tools survive a framework switch. If your agent's memory and state are abstracted behind a standard interface, they survive too.

The framework wars in 2025 look a lot like the orchestrator wars of 2018 (Kubernetes vs Docker Swarm vs Mesos vs Nomad). The market eventually consolidated around a small number of survivors, and the differentiation moved up the stack to the application layer. Agent frameworks are likely on the same trajectory: a year or two of multi-framework competition, then consolidation around two or three winners, then the differentiation moves to the agentic-application layer above.

Where Strands fits in this

Strands is a credible entry that gives AWS a coherent answer in the agent conversation. For shops already on AWS, it's the right default; for shops not on AWS, it's not particularly compelling.

The strategic question for AWS isn't whether Strands is good (it is) but whether the agent-framework choice ends up being the lever that decides architecture decisions. It probably won't be. The lever is the model and the foundation; the framework is a thin layer on top. AWS already had the foundation story (Bedrock plus the AWS service surface); Strands gives them a coherent way to expose it, which is the actual win.

For my own routing: Strands joins the "use it if you're on AWS" pile alongside Semantic Kernel for Microsoft and the OpenAI/Anthropic SDKs for their respective home shops. The thin-abstraction-layer pattern continues to be how I keep my own stuff portable. The framework wars are real and mostly the wrong thing to be paying attention to.