How to run a first Strands Python agent

The Python quickstart is built for one outcome: a first running agent. Install the SDK, pick a model provider, run the agent, then give it a tool. Everything past that — streaming, memory, observability, deployment — has its own guide. This walkthrough stays on the default provider, Amazon Bedrock, so the first file never builds a model object.

Install the SDK

You need Python 3.10 or newer and a virtual environment that is already activated. The quickstart does not include the commands that create or activate that environment. It points at the Python documentation on virtual environments if you still need to set one up.

Then install the Strands Harness SDK:

pip install strands-agents

That single install is enough for Bedrock. The same page has provider tabs for Anthropic, OpenAI, Google, and Ollama. Each of those needs an extra and a model object. Bedrock needs neither. If your provider is not in those tabs, the page also names LiteLLM, Mistral, SageMaker, Llama API, llama.cpp, Writer, OpenAI-compatible endpoints, and a custom provider you write.

Give Bedrock credentials

Amazon Bedrock is the default provider, using Claude Sonnet 4.6 in the us-west-2 region. That is why the sample has no model object and no extra install.

The SDK still needs AWS credentials with permission to invoke the model. The quickstart lists three ways:

Set the AWS_BEARER_TOKEN_BEDROCK environment variable to a Bedrock API key. The page calls this the quickest option for local development.
Use AWS credentials: aws configure, or the AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and optionally AWS_SESSION_TOKEN environment variables.
Use an IAM role when the process is already on a service such as EC2, ECS, or Lambda.

Enable access to the models you use in the Amazon Bedrock console before you run the file. The quickstart sends you to the AWS model-access documentation for that step. It does not list the console clicks, so follow that documentation rather than guessing a menu path.

Create and run agent.py

The model, when you use one, is a single object handed to the agent. The rest of the code is the same across providers. On Bedrock you skip the object. Create agent.py with this snippet:

from strands import Agent

# Bedrock is the default, so no model object is needed.
agent = Agent()
agent("What is an agent harness, in one sentence?")

Run it with the command from the quickstart:

python -u agent.py

The agent streams the response to your console. The page does not include a sample answer, so do not expect a fixed sentence back. To silence that streamed output, pass callback_handler=None to the Agent. Either way, every invocation returns an AgentResult carrying the run's messages, metrics, and traces.

Add letter_counter and file_editor

At this point you have a working agent loop and nothing for it to act with. It can only answer from what the model already knows. A tool is a function the model can decide to call. Tools come from two places: vended tools that ship with the SDK, for jobs such as editing files, running shell commands, and making HTTP requests, and any Python function you mark with the @tool decorator. The quickstart uses one of each.

Put this at the top of agent.py. The docstring and type hints are what the model reads to decide when to call the tool and what to pass it:

from strands import Agent, tool
from strands.vended_tools import file_editor

@tool
def letter_counter(word: str, letter: str) -> int:
    """
    Count occurrences of a specific letter in a word.

    Args:
        word (str): The input word to search in
        letter (str): The specific letter to count

    Returns:
        int: The number of occurrences of the letter in the word
    """
    if len(letter) != 1:
        raise ValueError("The 'letter' parameter must be a single character")
    return word.lower().count(letter.lower())

Replace the agent creation and the prompt. Both tools go in the tools list. On the Bedrock tab there is still no model argument. If you set a model for another provider, keep that line and pass it next to tools.

agent = Agent(tools=[letter_counter, file_editor])
agent('How many letter R\'s are in the word "strawberry"? Write the answer to answer.txt.')

Run python -u agent.py again. The model works out that counting letters is what letter_counter is for and that writing a file is what file_editor is for, calls both, and leaves answer.txt in the working directory. You wrote one of those tools. The other came with the SDK. The quickstart does not show the file contents, so check that answer.txt was created rather than matching a count the page never prints.

What the agent loop did

The agent decides when to call a tool based on the request, loops until it has an answer, and streams the response to your console. Every pass adds to the conversation history. The model decides the next step from the prompt plus that history. Tool calls are executed and their results come back into the loop. When the model makes no tool call, the result is the final message.

That is the first running agent on this page: pip install strands-agents, a default Bedrock agent with no model object, then letter_counter and file_editor on a prompt that needs both.

What to do next

Run the Bedrock file, then the tools version, and confirm answer.txt is in the working directory. From the quickstart's Next Steps, read the Agent Loop guide for the cycle above, then Vended Tools if you want more SDK tools in the same tools list. Model Providers covers every supported provider if you leave the Bedrock default. Streaming, memory, observability, and deployment each have their own guide from that section. The page also documents an optional MCP server for coding assistants. It helps while you build, and it is not required to run an agent.

Sources

Python Quickstart