Strands Agents vs. AgentCore
A practical breakdown of Strands Agents, the open-source SDK for writing agent logic, and Amazon Bedrock AgentCore, the managed platform for running agents securely in production.
Overview
If you've been following the AWS AI ecosystem, you've probably encountered both Strands Agents and Amazon Bedrock AgentCore. While they may sounds superficially similar, they operate at very different levels of the stack. One helps you write your agent. The other helps you run, secure, and scale it in production.
In this article, we will unpack both. We will then discuss the broader question this raises: what's the difference between an agent framework and an agent platform, and why does that distinction matter?
Strands Agents: the Framework
Strands Agents is an open-source SDK that AWS released in May 2025, originally built internally to power Amazon Q Developer. The core idea is simple: instead of wiring up complex orchestration logic yourself, you hand the heavy lifting to the model. You define a system prompt and a set of tools, and the LLM figures out the rest.
The model-first philosophy is what separates Strands from older frameworks like LangChain or Semantic Kernel. Rather than encoding flow logic in your application code, Strands trusts state-of-the-art models to plan, reflect, and select tools on their own. AWS reports that teams using Strands internally went from months-to-ship to days-to-ship for new agents on Q Developer.
What it is: An open-source SDK available in Python (and TypeScript in preview), model-agnostic (supports Bedrock, Anthropic, OpenAI, Ollama, and more), with native MCP tool support and 20+ pre-built tools out of the box.
What you get: Agents in a few lines of code, multi-agent patterns like swarm and agent-as-tool, and deep native integration with AWS services, all without needing to hand-wire orchestration logic yourself.
TLDR: Strands is what you use to write the agent. It's the code that defines what your agent knows, what it can do, and how it reasons.
Amazon Bedrock AgentCore: the Platform
AgentCore, now generally available as of October 2025, is a different animal entirely. It's not a framework for building agent logic. It's a managed platform for deploying, securing, connecting, and operating agents at enterprise scale. It is the infrastructure layer that sits beneath whatever framework you chose to build with.
Its core services cover the full operational surface area:
- Runtime: serverless execution with sessions up to 8 hours
- Gateway: turns your existing APIs and Lambda functions into agent-ready MCP tools
- Identity: handles secure auth to AWS services and third-party tools like Salesforce, GitHub, and Slack
- Memory: persistent and episodic agent memory across sessions
- Browser & Code Interpreter: managed sandboxes for web automation and code execution
- Observability: CloudWatch dashboards, OpenTelemetry support, integrations with Datadog, Langfuse, and more
- Policy: real-time tool call enforcement using Cedar rules, without touching agent code
- Evaluations: 13 pre-built quality metrics for correctness, safety, and tool selection accuracy
- Harness: managed agent harness in AgentCore that handles the environment, compute, memory, identity, networking, and observability via config
The key phrase on the AgentCore homepage is: "build agents your way using any framework, model, or tool." Framework and model agnosticism is a deliberate design choice made by the AgentCore service team. AgentCore doesn't care whether you built your agent with Strands, LangChain, LlamaIndex, or a completely custom loop or whether your agent does inference through Bedrock or first-party model providers.
Frameworks vs. Platforms: the General Pattern
Strands and AgentCore divide responsibilities cleanly. Strands provides the developer-facing abstractions for implementing agent behavior, while AgentCore provides the production services required to execute that behavior reliably under real enterprise constraints.
Below is a table outlining the division of responsibility across each of the layers:
Layer | Example | Responsibilities |
|---|---|---|
Agent platform | AgentCore | Runtime, memory, security, observability, tool connectivity |
Agent framework | Strands | Agentic loop, tool selection, multi-agent orchestration, prompts |
Foundation model | Claude, GPT-4, etc. | Reasoning, planning, tool calls, reflection |
A framework helps you express what the agent does. A platform handles everything around the agent once it's in the real world. These are complementary solutions and in most serious production deployments you need both.
Other examples of this split exist across the ecosystem: LangGraph (framework) can run on LangSmith or a custom cloud setup. CrewAI (framework) can be deployed through CrewAI's cloud or self-hosted. What AWS has done with Strands + AgentCore is make both layers first-class, named products, which attempts to make the distinction explicit.
Can you use them together?
Yes, and it's natural to do so. Strands has built-in integration with AgentCore Runtime; you can deploy a Strands agent directly to AgentCore's serverless execution environment with minimal extra code. AgentCore Gateway then gives that agent access to your existing APIs and tools, Memory gives it continuity across sessions, and Observability tells you how it's performing in production.
Do you have to use them together?
No. Strands runs fine on Lambda, Fargate, EC2, or EKS without any AgentCore services. It's open-source and deployment-agnostic. Conversely, AgentCore will happily host agents built with LangChain, a custom Python loop, or anything else communicating via HTTP. The two are designed to complement each other, but neither requires the other.
Conclusion
If you're just getting started building an agent, Strands is where to start. It gets you from zero to a running agentic loop in minutes, with sensible AWS defaults. When you're ready to take that agent to production, when you need real security, persistent memory, tool connectivity at scale, and the ability to monitor and evaluate quality over time, AgentCore is the layer that makes that possible without rebuilding infrastructure from scratch.
Strands and AgentCore are not a required pair. You can use either independently, or combine AgentCore with another framework. But when building on AWS, using both can remove much of the infrastructure work required to get you from working prototype to scalable production agent.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article