Strands Agents SDK vs Bedrock AgentCore

Key Concepts

• Agentic Loop: The iterative process where an LLM analyzes input, performs "thoughts," executes actions (tools/memory), evaluates results, and repeats until a final output is reached.
• Strands Agents SDK: A model-agnostic framework used to develop and orchestrate agentic workflows locally.
• Amazon Bedrock Agent Core: A managed, serverless AWS platform designed to host, deploy, and run agentic applications, abstracting away infrastructure management.
• MCP (Model Context Protocol): A standard for connecting AI agents to external data sources, APIs, and tools.
• Orchestration: The management of the agentic loop, including tool usage, memory, and multi-agent collaboration.

---

1. Strands Agents SDK: The Development Framework

The Strands Agents SDK serves as the "brain" and orchestration layer for building agents. It is a toolkit, not a service, similar to the AWS Cloud Development Kit (CDK).

• Core Features:
  • Model Agnostic: Supports various LLMs (e.g., Claude via Bedrock, OpenAI).
  • Tooling: Includes 20+ built-in tools (HTTP requests, math, file I/O, AWS services) and supports custom tool creation via Python decorators.
  • Memory & Context: Manages session state and long-term memory.
  • Multi-Agent Collaboration: Supports "fan-out" patterns where sub-agents report to a primary agent.
  • Observability & Evals: Provides built-in logging, metrics, and evaluation tools to ensure agent accuracy.
• Limitations: Currently restricted to Python and TypeScript.
• Development Workflow: Developers define the agent logic, add tools using @tool decorators, and test locally before choosing a deployment target.

2. Amazon Bedrock Agent Core: The Managed Infrastructure

Bedrock Agent Core is a serverless platform that removes the "minutia" of infrastructure management, such as setting up databases for memory or configuring Lambda functions for compute.

• Managed Components (A La Carte):
  • Runtime: A micro-VM compute layer (likely Lambda-based) for executing agent workflows.
  • Memory: Managed persistence for short/long-term storage without needing to configure external databases.
  • Gateways & Identity: Governed access to MCP servers and APIs, handling authentication (JWT/OAuth) and authorization.
  • Browser & Code Execution: Built-in capabilities for web navigation (Playwright/Selenium) and sandboxed code execution.
  • Observability & Registry: Centralized logging, metrics, and a searchable catalog for organizational agent reuse.
  • Policies & Evals: Integration with the Cedar language for fine-grained access control and automated performance tuning.
• The "Harness" Concept: A configuration-driven approach (currently in preview) to stitch together the entire agentic workflow.

3. Comparison and Integration

The video highlights that these two tools are not mutually exclusive but serve different stages of the lifecycle.

• The "Gotcha" of Integration: Developers can start with the Strands SDK and deploy to Bedrock Agent Core, or start with the Agent Core CLI, which generates a project structure that uses Strands under the hood.
• Deployment Comparison:
  • Manual (Lambda/Fargate/EKS): Requires the developer to manually manage DynamoDB for memory, CloudWatch for logs, and IAM roles for tool access.
  • Managed (Bedrock Agent Core): Automates the above, allowing developers to focus on application logic rather than infrastructure.

4. Strategic Recommendations

The presenter provides a clear framework for choosing the right path:

1. Development: Always use Strands Agents SDK for local development and testing due to its ease of setup and rapid iteration.
2. Simple/Contextless Apps: If the agent is a simple, single-shot Q&A tool, deploy to AWS Lambda.
3. Advanced/Production Apps: If the application requires memory, persistence, and complex tool integrations, use Bedrock Agent Core to avoid the complexity of managing the underlying infrastructure.
4. Full Control: Only "roll your own" infrastructure (managing your own databases and compute) if you have highly specific requirements that a managed service cannot satisfy.

Synthesis

The distinction between the two is fundamental: Strands Agents SDK is the "how" (the code and logic of the agent), while Bedrock Agent Core is the "where" (the managed environment that runs and scales that logic). By using Strands for development and Bedrock Agent Core for deployment, developers can significantly reduce the operational overhead of building sophisticated, production-ready AI agents.