AI Engineer World's Fair 2025
Introducing Strands Agents, an Open Source AI Agents SDK
Read the talk
Building Strands Agents from Models and Tools
A file summary that speaks and a Manim animation generator show how Strands delegates tool selection to a model—and what remains in the surrounding application.
From a talk by Suman Debnath
Before you start: Basic Python knowledge, including imports, functions, and decorators, will help you follow the examples.
How much workflow does an agent need?
How much of an agent’s workflow must you prescribe before the model can do useful work? Strands Agents starts with two ingredients: a model and tools. Its design motivation is to let increasingly capable models reason about the task and choose tools, reducing the need to encode each step in application scaffolding. The developer supplies capabilities; the model decides how to use them in response to a request.
That approach does not require a Bedrock-hosted model. The named integrations serve different purposes: LiteLLM provides access to alternative model providers, Langfuse supports observability, and Ollama allows local experimentation. The agentic-loop diagram puts the agent between the incoming prompt, the model, and the tools, with a result returned to the user. Even the two strands in the logo represent the model and tools.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Read a chapter, save a summary, and speak it
The first task makes that division of responsibility concrete: read a file from disk, summarize it, save the summary locally, and speak the result. Reading, writing, and speech use supplied Strands tools; summarization is the model’s contribution. No custom tool is needed for this workflow.
Install the SDK and its tools package:
bash
pip install strands-agents strands-agents-tools
The packages separate the agent runtime from the ready-made capabilities you register with it. You can use those supplied tools first and introduce custom functions when the task needs them.
The recording then configures the model. Debnath identifies Claude 3.7 Sonnet through Amazon Bedrock as the demo-era default; this is historical behavior, not a guarantee about today’s SDK. An explicit model configuration can replace the default, including a different provider such as Ollama. The example also supplies a system prompt. Debnath suggests trying the application without it, but that variation is not demonstrated.
The essential Python construction is an Agent with a tool list and a task request. Using the documented tool identifiers file_read and file_write, the chapter-ten workflow can be expressed as:
python
from strands import Agent
from strands_tools import file_read, file_write, speak
agent = Agent(tools=[file_read, file_write, speak])
agent(
"Read chapter10.txt, summarize it, write the summary to "
"chapter10-summary.md, and speak the summary aloud."
)
The recording’s configuration additionally passes the model and system prompt. The important boundary is the same: the application registers tools and requests an outcome instead of directly calling each tool in a fixed sequence.
During playback, the agent reads the file, produces a summary, writes it, and calls the speech tool. The terminal shows the three tool calls beside the agent code. Audible output then begins by explaining that the human eye functions like a camera, with light entering through the cornea: the result has reached the speech stage, not merely a text response describing what the agent intends to do.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give the agent a mathematical animation tool
The second demonstration moves from local file operations to mathematical animation. Its inspiration is 3Blue1Brown and Manim, the programmatic animation family associated with that channel. Eigenvalues, eigenvectors, and singular value decomposition are natural candidates: a visual transformation can make their meaning easier to follow.
The setup assumes an existing MCP server that can execute Manim code and generate videos. Strands does not replace that implementation. The application imports Agent and MCPClient, then configures the client to connect to the server. The server is the capability provider; the client makes those capabilities available to the agent.
In the file example, the application explicitly supplied file and speech functions. Here it supplies the tools discovered through manim_mcp_client.list_tools_sync(). That call obtains the server’s tool definitions for the agent; it is not a broadcast of the agent to the server.
The core wiring, given a configured client, is:
python
from strands import Agent
from strands.tools.mcp import MCPClient
def visualize(manim_mcp_client: MCPClient, prompt: str):
with manim_mcp_client:
agent = Agent(
tools=manim_mcp_client.list_tools_sync()
)
return agent(prompt)
Discovery and invocation stay inside the client context so that the MCP connection remains available while the agent uses its tools.
The demonstrated prompt requests a visualization of a cubic equation over x from −3 to 3. The same interface could accept other educational requests: visualize byte-pair encoding, explain SVD, or show multiplication of two 2×2 matrices. These are suggested prompts, rather than additional outputs shown in the demonstration.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Run the server, then request the video
The demonstrated local setup runs in this order:
- Start the MCP server and make it available on localhost.
- Run
app.py, which contains the Strands client application. - Submit the cubic-visualization prompt.
Starting the server first gives the application a live endpoint from which to discover and call tools.
The resulting animation is presented as generated without manual intervention. Debnath emphasizes that the abbreviated agent code does not prescribe the reasoning through a detailed system prompt: the model is expected to work out how to satisfy the request. He also notes that a prompt can specify a video duration, such as ten or thirty seconds. Those are requested output lengths, not measurements of generation latency. Compared with writing a Manim scene manually, the attraction is being able to describe the desired visualization and let the model produce the code through the tool workflow.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
What the short agent example leaves out
The code walkthrough first opens the server. It uses FastMCP and exposes two functions as tools through the mcp.tool decorator. This is where the executable capabilities live; the compact Strands client relies on that server-side implementation.
The fuller client then qualifies the earlier minimal-scaffolding description. The presentation showed only a few lines from main; before the agent call, the application also supplies a Manim construction example. Debnath describes this as one-shot prompting. The visible example defines a scene that creates a circle, sets its blue fill and stroke, and uses animation and wait calls. The model therefore receives a concrete pattern to follow, even though the agent construction itself is short.
Tool discovery and agent invocation remain compact, but they are not the whole application. A while True loop around the interaction supplies repeated requests and gives the program a chat-like experience. The distinction is useful: Strands handles the model-and-tool interaction, while the application still owns connection setup, example context, and its user-facing interaction loop.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Mix custom functions with supplied tools
A custom capability need not live behind MCP. To turn a Python function into a Strands tool, import the singular tool decorator from strands and apply @tool to the function. Debnath briefly shows a retrieval function as an example without walking through its retrieval implementation.
The decorated function goes into the same tools list as supplied functions. For example, a small text-counting capability can sit beside the file and speech tools:
python
from strands import Agent, tool
from strands_tools import file_read, file_write, speak
@tool
def count_words(text: str) -> int:
"""Count whitespace-separated words in text."""
return len(text.split())
agent = Agent(
tools=[count_words, file_read, file_write, speak]
)
The agent now has both application-specific behavior and ready-made I/O capabilities available for selection. Adding the custom function does not require replacing the supplied tools or creating a separate agent.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Build and contribute an example
The closing points readers toward the launch announcement, project documentation, and GitHub. Debnath also directs attendees to booth demonstrations involving Strands, Lambda, and MCP. Lambda appears here as a pointer to further examples; the recording does not walk through a deployment.
The invitation is to extend the open source project through working examples: share what you build, contribute a pull request to the Strands samples repository, and send feedback. The demonstrated progression supplies a practical starting point—use existing tools, connect a specialized server when needed, and expose your own functions as the application’s capabilities grow.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
The launch announcement explains the model-driven agent loop and includes a Python example combining MCP and supplied tools.
Project documentation and getting-started examples for building agents with models and tools.
Tool implementations and usage examples, including file reading, file writing, and speech output.
Official agent examples and a place to contribute additional samples.
Further reading
Suman Debnath describes his experiment generating mathematical animations from prompts with Strands and Manim.
Explains ManimCE, ManimGL, their shared origins, and how to identify which version a scene requires.
Read the complete timestamped transcript
- 0:00
[upbeat music] All right. So what we are gonna do is I'll quickly go through, uh, couple of demos.
- 0:19
That's all. That's, that's, that's the plan. Uh, so Strands is an open source SDK, uh, which has only one motivation, is to make your agents as simple as possible without any scaffolding.
- 0:34
The only thing that is needed is tool and the model.
- 0:41
That's all. There is no scaffolding. You don't have to de- uh, dictate of what the agent should do. And the idea is
- 0:49
since the models are becoming more and more intelligent, we want the model to take, uh, the reasoning part of our agents. We don't want to scaffold with lot of prompts, lot of, uh, system prompts, uh, a lot of backgrounds and all that.
- 1:05
So that's, that's, that's all to it. And it is also integrated with, uh, various, uh,
- 1:12
third-party, uh, providers like, uh, Langfuse, uh, LiteLLM. You can use any model of your choice. You don't need to use Bedrock-hosted models, but, uh, you can go ahead with any of the model of your choice using LiteLLM.
- 1:27
And also, you can, uh, use Ollama if you want to test it out locally.
- 1:34
Now, this is the agentic loop that we have in Strands. As I mentioned, it's just the models and the tools. That's all. And that is actually the two strands in this, uh, logo of Strand denotes one is for model, one is for tool.
- 1:49
I just happened to know this yesterday, so yeah. Okay. So now let's see a demo, how, how you can create, uh, uh, a Strand agent. So the demo that we are gonna have now, it's very simple.
- 2:04
We are going to read one file from our disk, and then we will generate a summary of that. Then we will write that summary into our, uh, local drive.
- 2:14
And then we will also tell the agent to speak out the result. So basically, we are trying to add the voice aspect of this, okay? For now, there are three things we are doing: reading a file, writing a file, and generating a speak, uh, speech.
- 2:30
All of these three, we are doing it using the default tools from Strands. So you don't have to write any custom tool for this. You just have to install, uh, Strands tool, and boom, you can get started with this, okay?
- 2:44
So just remember this, uh, use case. Uh, I have recorded this because I heard that the Wi-Fi is pretty fantastic here, so. [laughs]
- 2:53
Uh, all right. So let's see how, how it goes.
- 3:00
So here, uh, the first thing we need, we need to do is we need to install Strands. So that is what we are doing here.
- 3:09
Uh, we are just installing the Strands agent, and then we are going to install Strand tools. So this is simple pip install. Nothing fancy here. And when you install the Strands tool, it gives you a lot of default tools.
- 3:23
You can always make your own custom tools, uh, but, uh, this is how you can create, uh, uh, use, uh, out-of-the-box tools. So these are the three tools that we are going to use.
- 3:34
Now, we are going to write the application.
- 3:44
So the first thing that we need to do is we need to import strands. And by default, it uses Bedrock model, which is, uh, Claude three point seven under the hood.
- 3:54
But if you don't want to use that, you can always use any model of your choice. But by default, it uses Bedrock. I'm trying to show you how you can define the model, but later on when we create agents, you will see that you don't have to give model ID.
- 4:09
By default only it should work. But I just wanted to show you, if you want to define your own model, how you can define, uh, the model. Uh, in, in case you want Ollama, you can use Ollama there.
- 4:20
And now this is a system prompt. When I share the GitHub repo, try to do this. Delete the system prompt. It should still work. But I just want to, wanted to give you an intuition of how things work under the hood.
- 4:31
And if you see here, all we are doing here, we are giving the model ID, system prompt, and the tools. That's all. And now we are asking the same question that read this, uh, chapter number ten, uh, summarize that, and, uh, write it in a markdown file and speak out.
- 4:46
Now, to listen to the speech, let me increase the volume. So now it is reading the file, then it is trying to write the file after creating the summary, and now it should s- speak out.
- 4:59
The human eye functions like a camera with light entering through the cornea.
- 5:03
Okay. So you get the idea, right? So how these things work. Now, there is one more, uh, demo I have, which is around MCP with Strands, because without MCP and agents, I was told that you cannot have any talk in this conference. [laughs]
- 5:20
So, all right. How many of you have heard of, um,
- 5:26
[REDACTED:username] YouTube channel? Oh, wow. So you know what we are talking about. So we are trying to build animations and videos like what we see in [REDACTED:username]. It is powered by one of the, uh, library called Manim.
- 5:41
So I've been working with this Manim for a couple of years, uh, uh, to, uh... If you are from, uh, science and, uh, mathematics background, eigenvalue, uh, uh, you know, eigenvectors, SVD, these are the concepts which are very easily we can explain, uh, using visualization.
- 5:56
So what we are going to do now is we are going to create a Strands agent
- 6:03
using
- 6:05
An MCP server which will help me to generate these videos using Manim.
- 6:11
With me so far? Yeah. So this is how we can do. Assume that we already have an MCP server which can generate this video, okay? Just assume that. It is not here, but it, it is, uh, uh, already there, okay?
- 6:27
So, so now what we are going to do is, using Strands, we are just going to
- 6:35
call the MCP client and make use of that server. So in this case, I'm importing the Strands Agent and the MCP client.
- 6:45
The next thing that we are going to do is we are going to create the MCP client. And if you see here,
- 6:51
the-- this is my MCP server path where I have written the code to execute that MC, uh, Manim, uh, code. So that-- this particular code I'm not showing, but after this I will show it to you what, uh, that code is doing.
- 7:07
But that's all. I don't have to do anything else. Now, when I create an agent... In the previous example, if you, if you remember, we mentioned that
- 7:18
agent, then tools equal to read file, write file, and speak. In this case, I'm not using any of the default tools. My tool is nothing but the MCP server.
- 7:30
And for that I'm just using tools equal to manim_mcp_client.list_tools_sync. So this will, this will broadcast all the tools that the MCP server has to my client. So that is nothing but the Strands Agent.
- 7:46
With me so far? Yes? Perfect. And at the end, we are just going to give the prompt. So in this case, you can give any prompt of your choice.
- 7:54
Uh, but here we are just saying that create a, um, a visualization, uh, for this cubic equation within the range of x minus three to x equal to three.
- 8:04
If you want to try this with something else, you can always give like, um, "Explain me byte-pair encoding, uh, in a visual way." Or you can say, uh, "Explain SVD.
- 8:13
Explain how two, uh, two metrics of two by-- two cross two, um, uh, you know, perform a metric multiplication," or whatever, right?
- 8:24
So now let's see this. So for this, before I start the MCP client or the Strand Agent, I have to make sure that server is up and running, right?
- 8:33
So in the-- here, I'm just making the MCP server up so, so that this is available in that, uh, local host. And now I'm running this app.py, which contains the code which we have seen a while back.
- 8:47
So finally, we can just give the prompt. So this is the same prompt that we have seen in the previous slide, and let's see, uh, what it generates.
- 8:58
And if you notice, we have not mentioned any, um, uh, any scaffolding, kind of a like system prompt and all that. We want the model to reason about this and figure it out of its own.
- 9:14
So I have not done anything. This is-- and it is not photoshopped. It just came up like that.
- 9:25
And you can actually define the duration of the video, let's say thirty seconds, ten seconds, and all that.
- 9:32
And if you have worked in Manim to generate this code, it takes some time, right? So i-it's not that straightforward. Okay? So that's about the integration with, uh, MCP and Strand.
- 9:47
And before I show you a few of the resources, let me show you the code.
- 9:55
No one pings me while I am working, but everybody pings when... [laughing]
- 9:59
Okay. All right, so this is the... So this is the MCP server that I have. It just-- I have some, uh, I have imported, uh, FastMCP, and
- 10:22
this is the, this is couple of, couple of the, uh, um, tools that I have defined. And if you see this here, the way that you can create an MCP tool is just wrap it around with an mcp.Tool, a decorator, right?
- 10:35
So this becomes-- these two are the tools for my MCP server. And when I come here...
- 10:44
Not this one. When I come here, and if you look at
- 10:49
the main function, so this is the function where I'm going to call that using Strands Agent and MCP client, right? Uh, so I-- what I've shown in the presentation is just few lines from this main function, but we are doing little bit more, uh, before ac- uh, before just calling, uh, the agent.
- 11:08
We are listing the tools. But before that, uh, we are also giving some examples. And if I show you this example...
- 11:19
I'm just giving one example of how to create, uh, you know, a, a, an, and a, and construct in-- using Manim. That's all. You can think of it like, uh, one-shot prompting.
- 11:31
Uh, it's like that. Uh, but my-- as far as the agent is concerned, it's just, uh, one line of code. Uh, you know, we just list the tools, and then here we are just calling the agents.
- 11:45
That's all. And then we have a while true loop so that we get an interactive, uh, chat kind of an experience. Okay? And in our first, uh, demo, um...
- 12:00
Uh, not first demo. I want to show you one quick thing, is, uh, how you can create-
- 12:06
A custom, uh, tool. Okay? This is, uh... I'm just jumping around a couple of things because we just have two, three minutes. It's, it, it's no less than a time bomb, trust me, when I see this.
- 12:18
Right. So, let's say you have any function. Okay. Uh, let me just quickly scroll down and show it to you.
- 12:32
Yeah. So if you have any function, and you want to c- uh, create that function, uh, you know, turn that function into a tool, all you have to do is this.
- 12:43
Uh, where is that? Yeah. All you... Let's say this is a function. Yeah, this is a different example. Uh, it's there in the GitHub, but I will not explain that.
- 12:54
But the idea is, let's say you have a function, you want to convert that into a tool. All you have to do is just import s- uh, tools from here and decorate it with tools.
- 13:03
Once that is done, this retrieve_from_quadrant will become
- 13:08
a, a tool for you. So next time when you create an agent, when you create an agent, we just give that as a tool. And now here, in this list of tools, you can give your custom tool as well as your default tools, whatever we have.
- 13:23
Read_file, write_file, speak, and so on and so forth. Okay? So that's, that's about it. Now, if you want to learn more about Strands,
- 13:33
uh, we have a GitHub repository. So this is the launch blog. Um, this is the documentation, which is nothing but strandsagent.com, and this is the GitHub link. Okay. And if you have any questions, uh, feel free to, uh, you, you know, ask me.
- 13:52
I, I'll be around. And we have a booth inside as well. Uh, there are plenty of demos, uh, with, uh, Strands, with Lambda, MCP and, uh, you know, to, do to get started.
- 14:03
This is an open source project. Feel free to raise a PR if you have something, if you have built something into the samples, uh, code repository within Strands, uh, GitHub.
- 14:12
And, uh, yeah, uh, share what you built, and, uh, if you have any feedback, let us know. Thank you so much. [audience applauding] [upbeat music]