# Introducing Strands Agents, an Open Source AI Agents SDK

Suman Debnath, AWS | AI Engineer World's Fair 2025 | 14:26

Source: https://www.youtube.com/watch?v=Q3NreEAdKMc
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/introducing-strands-agents-an-open-source-ai-agents-sdk
Published: 2025-06-27
Tags: agents, mcp, open-source, tool-use

## TL;DR
- Strands Agents reduces an agent to a model, a prompt, and a set of tools, without requiring extensive orchestration scaffolding.
- The SDK can use built-in tools for file operations and speech, or connect to external capabilities through MCP servers.
- Strands Agents lets developers use models from Amazon Bedrock, LiteLLM, Ollama, and other providers while keeping the agent code small.

## Summary
Suman Debnath introduces Strands Agents, an open source SDK from AWS built around a model-driven approach. An agent can start with a model and tools, while the model handles reasoning and decides how to use those tools. He demonstrates a file workflow that reads a chapter, summarizes it, writes the result to Markdown, and speaks the output with built-in Strands tools. A second demo connects Strands to an MCP server that generates Manim animations, allowing prompts such as visualizing a cubic equation or explaining matrix multiplication. Debnath also shows how an ordinary Python function can become a custom tool with a decorator. The SDK defaults to Amazon Bedrock but supports other model providers through LiteLLM and can use Ollama locally. The examples are intentionally small, although the MCP server itself contains additional code and examples to guide generation.

## Key ideas
### Strands Agents puts the model in charge of the agent loop
[00:00](https://www.youtube.com/watch?v=Q3NreEAdKMc&t=0s)
Debnath presents Strands Agents as an open source SDK whose goal is to make agents simple without extensive scaffolding. He says the basic ingredients are a model and tools. The model handles the reasoning part, so developers do not have to specify every action through large system prompts, background instructions, or orchestration code. The agent loop is built around the model deciding when and how to use its tools. He also explains the two strands in the project logo as a reference to those two parts, the model and the tool.

### The SDK supports several model providers
[00:39](https://www.youtube.com/watch?v=Q3NreEAdKMc&t=39s)
Strands Agents is not limited to models hosted by Amazon Bedrock. Debnath names integrations with Langfuse and LiteLLM, and says LiteLLM can be used to work with a model of the developer's choice. Ollama is another option for local testing. The default configuration uses a Bedrock model, which he identifies as Claude 3.7, but developers can define a different model when they create the agent. In the example, he shows the model ID, system prompt, and tools explicitly, while explaining that the model can also be left to the default configuration.

### Built-in tools can handle a complete file and speech workflow
[01:59](https://www.youtube.com/watch?v=Q3NreEAdKMc&t=119s)
The first demo reads a file from disk, creates a summary, writes that summary to a local Markdown file, and speaks the result. These actions use default tools supplied through the Strands tools package, so Debnath does not write custom implementations for reading, writing, or speech. The setup starts with installing the agent package and the tools package with pip. He then gives the agent a request to read chapter 10, summarize it, write the result in Markdown, and speak it. The demo reads the file, creates the output, and produces spoken audio.

### An MCP server can give a Strands agent specialized capabilities
[04:58](https://www.youtube.com/watch?v=Q3NreEAdKMc&t=298s)
The second demo connects Strands Agents to an MCP server that generates Manim videos. Debnath uses this to create visual explanations of subjects such as vectors, singular value decomposition, cubic equations, and matrix multiplication. The Strands application creates an MCP client and passes the server's available tools to the agent with a tool-listing call. In the example, the MCP server runs locally, and the agent receives a prompt to visualize a cubic equation over a specified range. Debnath says the agent can reason about the request without a large system prompt and can generate videos with different durations.

### The MCP server exposes ordinary functions through decorators
[10:17](https://www.youtube.com/watch?v=Q3NreEAdKMc&t=617s)
Debnath shows the server code behind the Manim example. It imports FastMCP and defines functions that become MCP tools when wrapped with an MCP decorator. The client can discover those tools and make them available to the Strands agent. He also shows that the application includes an example describing how to construct a Manim object, which guides the model's code generation. The presentation omits some surrounding application code, including tool listing and the interactive loop, but the agent call itself remains a small part of the program.

### Custom Python functions can become Strands tools
[12:06](https://www.youtube.com/watch?v=Q3NreEAdKMc&t=726s)
A developer can turn an existing function into a tool by importing the Strands tools support and applying its decorator. Debnath uses a retrieval function named retrieve_from_quadrant as an example. Once decorated, the function can be passed into an agent in the same tools list as built-in operations such as reading files, writing files, and speaking. This gives an application one place to combine capabilities supplied by Strands with functions written for its own codebase. The agent then has access to those functions when interpreting a user request.

### The project invites users to extend its examples
[13:21](https://www.youtube.com/watch?v=Q3NreEAdKMc&t=801s)
Debnath directs viewers to the Strands Agents GitHub repository, the documentation at strandsagent.com, and the launch blog. He says the repository includes samples and that the project is open source. Developers can raise a pull request if they have built something for the samples code repository. He also points to demonstrations involving Strands, AWS Lambda, and MCP at the conference booth. The closing message is practical: install the SDK, inspect the examples and documentation, build an integration, and share feedback with the project.

## Notable quotes
- "The only thing that is needed is tool and the model." (00:00)
- "We want the model to take the reasoning part of our agents." (00:39)
- "All of these three we are doing it using the default tools from Strands." (02:20)
- "My tool is nothing but the MCP server." (07:04)
- "All you have to do is just import tools from here and decorate it with tools." (12:57)

## Tools & references mentioned
- Strands Agents
- AWS
- Amazon Bedrock
- Claude 3.7
- Langfuse
- LiteLLM
- Ollama
- MCP
- Manim
- Three Blue One Brown
- FastMCP
- AWS Lambda
- GitHub
- strandsagent.com

## Who should watch
- You are building an agent and want to avoid writing a large orchestration layer or many system prompts.
- Your application needs to combine a foundation model with local files, speech, custom Python functions, or an MCP server.
- You want to compare model-provider options, including Amazon Bedrock, LiteLLM, and Ollama, within a small Python application.

## Related talks

- [Building Agents at Cloud Scale](https://aietalks.com/talks/building-agents-at-cloud-scale) (Antje Barth, AWS, 19:00)
- [Building Agents with Amazon Nova Act and MCP](https://aietalks.com/talks/building-agents-with-amazon-nova-act-and-mcp) (Du'An Lightfoot, Amazon & Banjo Bami, AWS, 1:26:20)
- [The Rise of the Agentic Economy on the Shoulders of MCP](https://aietalks.com/talks/the-rise-of-the-agentic-economy-on-the-shoulders-of-mcp) (Jan Curn, Apify, 18:08)
- [Building Agents with Model Context Protocol](https://aietalks.com/talks/building-agents-with-model-context-protocol) (Mahesh Murag, Anthropic, 1:44:12)
- [Building voice agents with OpenAI](https://aietalks.com/talks/building-voice-agents-with-openai) (Dominik Kundel, OpenAI, 1:25:35)