Introducing Strands Agents, an Open Source AI Agents SDK

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.

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:

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:

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.

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:

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.

The demonstrated local setup runs in this order:

1. Start the MCP server and make it available on localhost.
2. Run app.py, which contains the Strands client application.
3. 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.

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.

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:

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.

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.