Introducing AWS Strands Agents: A New Paradigm in AI Agent Development

Introduction

As generative AI continues to evolve rapidly, we are discovering that the future of AI lies not in isolated models but in collaborative agent networks that mirror human-like problem-solving. The rapid evolution of generative AI has ushered in a transformative era for autonomous systems, with AI agents emerging as critical tools for automating complex workflows. At the forefront of this shift, Amazon Web Services (AWS) recently introduced Strands Agents, an open-source SDK designed to simplify agent development through a model-driven approach. This framework empowers developers to build sophisticated AI agents with minimal code while retaining complete control over customization, tool integration, and deployment. In parallel, AWS continues to enhance its managed service, Amazon Bedrock Agents, which streamlines enterprise-grade AI automation. This post explores Strands Agents’ capabilities, contrasts them with Amazon Bedrock Agents, and provides a hands-on tutorial for building a Perplexity-like web search agent with access to multiple tools.

The future of AI lies not in isolated models, but in collaborative agent networks that mirror human problem-solving.

Understanding Strands Agents

Strands Agents reimagines AI agent development by leveraging the inherent reasoning and planning capabilities of modern large language models (LLMs). Unlike traditional workflow-based frameworks that require rigid step-by-step definitions, Strands Agents adopts a model-first philosophy where developers specify three core components:

Model: Supports Amazon Bedrock, Anthropic Claude, Meta Llama, Ollama, and other providers via LiteLLM.
Tools: Integrate pre-built tools (e.g., calculator, Python REPL) or custom Python functions using the @tool decorator.
Prompt: Define the agent’s task and behavior through natural language instructions.

Key Features of Strands Agents

Provider Agnosticism: Deploy agents across Cloud, hybrid, or local environments with support for multiple LLM providers.
Production Readiness: Built-in observability via OpenTelemetry, metrics, logs, distributed tracing, and production-ready reference architectures for AWS Lambda, AWS Fargate, and Amazon EC2.
Multi-Agent Collaboration: Coordinate specialized agents (e.g., Researchers, Analysts, and Writers) to solve complex problems through peer-to-peer or supervisor-led workflows.
Tool Ecosystem: Access thousands of Model Context Protocol (MCP) servers and 20+ pre-built tools, including http_request for API interactions and retrieve for RAG workflows.

Agent Loop

According to the documentation, Strands Agents’ Agent Loop is a core concept in the Strands Agents SDK that enables intelligent, autonomous behavior through a cycle of reasoning, tool use, and response generation. It is the process by which a Strands agent processes user input, makes decisions, executes tools, and generates responses. It’s designed to support complex, multi-step reasoning and actions with seamless integration of tools and language models.

Strands Agents vs. Amazon Bedrock Agents

While similar in many ways, Strands Agents and Amazon Bedrock Agents also differ considerably in their architectural design. Amazon Bedrock Agents use OpenAPI schemas with Action Groups to define the structure and parameters of the APIs they can invoke, enabling the agent to understand and interact with external services in a standardized way. In contrast, AWS Lambda functions are the backend implementations for these actions. When an agent receives a user request, it consults the schema to determine which Lambda function to call, passes validated parameters, and then returns the Lambda response to the user. This approach allows for seamless integration of business logic, automatic data validation, and a scalable, serverless execution environment for agent-driven workflows.

Let’s compare and contrast the features of Strands Agents to Amazon Bedrock Agents:

Use Case Guidance

Strands Agents: Ideal for developers requiring granular control, multi-provider LLM support, or custom toolchains (e.g., research assistants with domain-specific APIs).
Bedrock Agents: Suited for enterprises prioritizing rapid deployment, managed security, and seamless integration with AWS services (e.g., insurance claim processing bots).

Demonstration: Web Search Agent

The following tutorial demonstrates how to create a web search agent built using Strands Agents framework and foundation models available on Amazon Bedrock. We will access state-of-the-art (SoTA) models via Amazon Bedrock, including Anthropic’s Claude Sonnet 4 and Amazon Nova Premier. Both are SoTA foundation models that deliver frontier intelligence and industry-leading performance.

Source Code

All of the open-source code for this article is published on GitHub. All the code can be found in a Jupyter Notebook, which can be run locally, such as in Microsoft’s Visual Studio Code, or on the Cloud.

Inspiration

This demonstration was inspired by the September 2024 AWS Machine Learning Blog, Integrate dynamic web content in your generative AI application using a web search API and Amazon Bedrock Agents, by Philipp Kaindl and Markus Rollwagen. In the post, the authors utilize Amazon Bedrock Agents with web search capabilities, integrating free external search APIs from Serper and Tavily AI, alongside a Bedrock Agent. We will recreate the same functionality using Strands Agents, converting the primary functionality into Strands Agents’ custom tools. We will combine these tools with Strands Agents’ pre-built tools to allow the agent to make complex decisions.

Prerequisites

To follow along with this blog post’s demonstration, you must register for a free Serper and Tavily API key.

Serper (Google Search API)

Serper provides low-cost Google Search API access with 2,500 free monthly searches:

Visit serper.dev/signup
Create an account using Google SSO or email
Navigate to Dashboard → API Keys
Copy your SERPER_API_KEY

Tavily (AI-Optimized Search)

Tavily offers 1,000 free monthly credits for its AI-enhanced search API:

Go to app.tavily.com/sign-up
Authenticate with Google, GitHub, or email
Access API Keys in your dashboard
Copy your TAVILY_API_KEY

Getting Started

To get started, follow along with the Jupyter Notebook on GitHub. First, install the necessary Python packages, including those for Strands Agents and the AWS Python SDK, boto3, using the built-in %pip magic command, which runs the pip package manager within the current kernel:

Next, after restarting the Notebook’s kernel, import the necessary package libraries and set up logging:

Strands Agents Quick Start

Let’s start with a quick preview of Stand Agents, as found in the Strands Agents GitHub Quick Start documentation. We will utilize the Amazon Nova Micro text-only model, which delivers the lowest latency responses at a very low cost, available on Amazon Bedrock. We are making the Strands Agents’ pre-built calculator tool available to the agent, which it should call to respond to the request:

We should receive a result similar to the following, indicating that the agent called the pre-built calculator tool to respond correctly to the request with the answer, 42:

I’ve added the built-in %%time magic command to all examples, so we understand how long the agent takes to respond, based on the complexity of the request and the model selected.

Metrics

Observability is a native feature of Strands Agents, including traces, metrics, and logs. According to Strands Agents’ documentation, metrics are essential for understanding agent performance, optimizing behavior, and monitoring resource usage. The Strands Agents SDK provides comprehensive metrics tracking capabilities that give you visibility into your agent’s operations. We can access individual metrics, like totalTokens and latencyMs, or use the get_summary() method to get all metrics as a nested JSON object:

Example results of get_summary() for the above calculator example:

Custom Tool Calling

Before we build our web search agent, let’s look at one more example from the Strands Agents GitHub Features at a Glance documentation. In this simple example, we define the Python method, word_count(), as a tool by using Strands Agents’ @tool decorator. Similar to the previous example, we then make the word_count tool available to the agent, which it can use if necessary to respond to the request. We will continue to use the Amazon Nova Micro model to save costs:

We should receive a result similar to the following, indicating the agent called the custom word_count tool to respond correctly to the request with an answer, seven words:

Securing API Keys

To start building the web search agent, we will first use AWS Secrets Manager to securely store the Serper and Tavily API keys. AWS Secrets Manager is a fully managed service that securely stores, rotates, and controls access to sensitive information like database credentials, API keys, and tokens. Although this step is not required with Strands Agents, it represents AWS’s best security practices. Make sure to replace the two SecretString placeholders below with your API keys before running the code:

Retrieving API Keys

Once your API keys are securely stored in AWS Secrets Manager, we must retrieve them for use by the custom tools we will create:

Defining Custom Web Search Tools

Next, we will define two custom web search tools, one for using Serper, google_search, and one for using Tavily, tavily_ai_search. Similar to the previous word count example, we define our tools by using the Strands Agents’ @tool decorator to annotate two Python methods. The Python Docstrings also play a critical role in describing the intended functionality of the tool to the agent through documentation.

Testing Tavily Search Tool

First, let’s test Strands Agents’ use of our custom tavily_ai_search tool. Although both web search tools are available, the agent should have the intelligence to call the tavily_ai_search tool to respond to the request. This time, we will try the recently released Anthropic Claude Sonnet 4 model, available on Amazon Bedrock since May 22, 2025:

Based on the request, the agent should respond as follows, indicating that it used the tavily_ai_search tool:

After a few tests, I lowered the temperature to 0.1, since when I first ran the above code with a temperature of 0.2, the agent incorrectly indicated that Claude 4 was released in May 2024, not May 2025. No matter how good the model, always double-check the accuracy of the results.

Testing Serper Search Tool

Next, let’s test Strands Agents’ use of our custom google_search tool. Again, although both web search tools are available, the agent should have the intelligence to call the google_search tool this time, to respond to the request. Again, we will try the recently released Anthropic Claude Sonnet 4 model:

Based on the request, the agent should respond as follows, indicating that it used the google_search tool to locate five current news items, which we did:

Multi-tool Use

Let’s finish the demonstration by using Strands Agents to make multiple calls to multiple tools to respond to a slightly more complex request. To answer completely, the agent must call at least two tools made available, and most likely, more than once. This time, I am using the Amazon Nova Premier model, the latest Nova model to be released on Amazon Bedrock. This model is the Nova family’s most capable model for complex tasks and a teacher for model distillation:

Based on the request, the agent should respond as follows, indicating it used multiple tools to generate a complete answer. Based on the output, the agent first used the tavily_ai_search tool twice, once to find the current US National Debt ($35.5 trillion) and once to find the current US population (340.1 million). Then, the agent used the built-in calculator tool to find the square root of the debt divided by the population: sqrt(35500000000000 / 340100000) = 323. Finally, it returned the answer as requested, approximately $323 per person:

Although the Amazon Nova Premier model is considered the best-performing Nova model, I found that Amazon Nova Pro often performed better on moderately complex tasks with Strands Agents. Amazon Nova Pro is a highly capable multimodal model with the best combination of accuracy, speed, and cost for a wide range of tasks. Use the best model to meet your requirements, which may not always be the largest or most expensive. For simple tasks, use smaller, faster, cheaper models including Amazon Nova Lite and even Micro.

Conclusion

As demonstrated in this post's simple example, Strands Agents represents a significant shift in AI development, democratizing access to sophisticated agentic systems while maintaining enterprise-grade robustness. Its open-source nature fosters community innovation, as seen in its integrations with Anthropic, Meta, Ollama, and LiteLLM.

Organizations weighing Strands Agents against Bedrock Agents must decide between control and convenience. Strands excels in scenarios demanding custom toolchains, multi-LLM strategies, or hybrid deployments, while Bedrock Agents accelerate time-to-value for AWS-centric workflows.

This blog represents my viewpoints and not those of my employer, Amazon Web Services (AWS). All product names, images, logos, and brands are the property of their respective owners.

Site Terms, Privacy, and more.