How to run a first Strands agent

The Strands Agents SDK is for building, managing, evaluating, and deploying AI-powered agents. Get started says the quickstarts get a simple agent running in less than 20 minutes. This is that first run only: an object in your process, not a control plane you provision. Amazon Bedrock is the default model. Another provider is a different object in the same constructor, not a hosted scheduler or database.

A library, not a platform

Strands runs inside your own process. Creating an agent is constructing an object in Python or Node.js. The overview says there is no hosted control plane, scheduler, or database to stand up first. Any model provider works. Amazon Bedrock is the default, and swapping in Anthropic, OpenAI, Gemini, or Ollama is a one-line change, so an AWS account is only required if you keep the default.

The only service the samples reach is the model provider. Adding an agent to an existing FastAPI, Express, or Next.js app is a dependency and a few lines of code, not new infrastructure. The SDK is available in Python and TypeScript. The overview says Ollama runs in the Python SDK only, and the feature table marks Ollama and LiteLLM as Python-only.

TypeScript: the documented first run

The TypeScript quickstart is the page with install commands. Use Node.js 22+ and npm, as the install section says. A coding-assistant prompt on the same page says Node.js 20+. Follow the install section.

In a new project directory, run the block the page shows:

npm init -y
npm pkg set type=module
npm install @strands-agents/sdk zod
npm install --save-dev @types/node typescript

That section is titled Install the Strands Harness SDK. The first invoke sample does not import zod, but zod is on the documented install line.

Amazon Bedrock is the default provider, using Claude Sonnet 4.6, so no extra install or model object is needed. Create src/agent.ts with the quickstart snippet:

import { Agent } from '@strands-agents/sdk'

// Bedrock is the default, so no model object is needed.
const agent = new Agent()
const result = await agent.invoke('What is an agent harness, in one sentence?')
console.log(result.lastMessage)

Run it with:

npx tsx src/agent.ts

The sample prints the last message on the result. Every invocation returns an AgentResult carrying the run's messages, metrics, and traces. To silence streamed console output, pass printer: false when creating the agent.

If you keep Bedrock, give the SDK credentials that can invoke the model. The quickstart lists three options:

Set AWS_BEARER_TOKEN_BEDROCK to a Bedrock API key. The page calls this the quickest option for local development.
Use aws configure, or set AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and optionally AWS_SESSION_TOKEN.
Use an IAM role on EC2, ECS, or Lambda.

Enable access to the models you use in the Amazon Bedrock console, following the AWS documentation the TypeScript quickstart links.

Python: construct the agent, then find the install

Get started shows this default Python agent. That page does not include a package install or a standalone Python run command. Refer to official documentation for exact syntax.

from strands import Agent

# Amazon Bedrock is the default, so no model object is required.
agent = Agent()
print(agent("What can you help me build?"))

Python calls the agent as a function and prints the return value. TypeScript awaits an invoke call and prints the last message field. Keep each language on its own sample.

The overview also puts that object in a route handler. Both files comment that the agent lives in this process, with no scheduler or database to reach. The overview prints these two files and the run commands below. It does not include install commands for FastAPI, pydantic, uvicorn, or Express. Refer to official documentation for exact syntax.

Python, run with uvicorn main:app:

from fastapi import FastAPI
from pydantic import BaseModel
from strands import Agent

app = FastAPI()

class ChatRequest(BaseModel):
    prompt: str

@app.post("/chat")
def chat(request: ChatRequest) -> dict[str, str]:
    # The agent lives in this process: no scheduler or database to reach.
    agent = Agent()
    result = agent(request.prompt)
    return {"reply": str(result)}

TypeScript, run with tsx server.ts:

import { Agent } from '@strands-agents/sdk'
import express, { type Request, type Response } from 'express'

const app = express()
app.use(express.json())

app.post('/chat', async (req: Request, res: Response) => {
  // The agent lives in this process: no scheduler or database to reach.
  const agent = new Agent()
  const result = await agent.invoke(req.body.prompt)
  res.json({ reply: result.lastMessage })
})

app.listen(3000)

Swap the model object

The model is one object you hand to the agent. Bedrock needs none. The overview says every other provider is a one-line swap and the rest of your agent code does not change. The TypeScript quickstart says the rest of your code is the same no matter which provider is behind it. The swap is the model argument. These snippets do not stand up a scheduler or database.

TypeScript Anthropic, from the quickstart, installs the provider package and reads the key from the environment:

npm install @anthropic-ai/sdk
export ANTHROPIC_API_KEY=<your key>

import { Agent } from '@strands-agents/sdk'
import { AnthropicModel } from '@strands-agents/sdk/models/anthropic'

// Reads ANTHROPIC_API_KEY from the environment.
const model = new AnthropicModel({ modelId: 'claude-sonnet-5' })
const agent = new Agent({ model })
const result = await agent.invoke('What is an agent harness, in one sentence?')
console.log(result.lastMessage)

The OpenAI tab installs the openai package and exports OPENAI_API_KEY. The Google tab installs its client package and exports GEMINI_API_KEY. Each tab then constructs a model and passes that object into the agent. The overview's TypeScript tabs pass an API key field in the constructor instead of reading the environment. Use the complete tab on the page you are following. Do not mix the two forms, and do not mix the TypeScript camelCase model id field with the Python snake_case field.

The quickstart describes the Bedrock default as Claude Sonnet 4.6. The Anthropic samples use a different model id. The pages do not explain the difference. Copy the id from the tab you chose.

Python tabs on the overview do the same swap for Anthropic, OpenAI, Google (GeminiModel), and Ollama: import a model class and pass it into the agent. Those tabs put a placeholder where a key would go. Copy the complete tab rather than retyping a key or a model id. Ollama is the Python-only case.

If your provider is not in those tabs, the TypeScript quickstart says Strands also supports the OpenAI Responses API, any provider in the Vercel AI SDK ecosystem, and a custom provider you write. Local models through Ollama are pointed back to the Python SDK.

What to try next

With Node.js 22+ and npm, run the install block, save the Bedrock file, set Bedrock credentials only if you keep the default, and run the tsx command shown above. To leave Bedrock, open that provider's tab on the TypeScript quickstart or Get started and pass the model object those pages show. For Python, use the no-argument construction above. Get started does not include a package install or a standalone Python run command. Refer to official documentation for exact syntax. After the first reply, the tools section on the TypeScript quickstart is the next documented step. It is separate from this first invoke.