strands-agents/sdk-python

Features

• AI Agent Orchestrators - Provides an SDK for building and orchestrating production-grade AI agents with tools, state, and multi-model support.
• Sequential Agent Execution - Orchestrates multiple agents in a sequential pipeline where each agent's output feeds into the next step.
• Custom Function Registrations - Registers arbitrary Python functions as callable tools for AI agents.
• Graph-Based Execution Loops - Executes agents within a graph-based model that supports looping and conditional branching between steps.
• Conversational Agent Development - Provides a builder for creating conversational agents that use tools and manage sessions.
• Agentic Execution Loops - Executes a conversational agent loop that processes user input and returns a response using a configured model.
• Agent Tooling - Attaches callable tools that the agent can invoke during a real-time conversation.
• Agent Configurations - Creates an agent with a single configuration object that sets the LLM provider, tools, and context.
• Policy Handlers - Applies policy handlers that inspect tool inputs and steer the agent toward correct usage.
• Tool Call Execution Loops - Validates, runs, and returns results of tool calls requested by the model, including error recovery without terminating the loop.
• Voice Agents - Maintains persistent streaming conversations with real-time audio and text, supporting interruptions and continuous input.
• Speech Interruption Handlers - Automatically pauses or adjusts agent speech when the user starts speaking during a conversation.
• Agentic Tool-Use Frameworks - Wraps any function as a callable tool with automatic schema inference and validation for agent use.
• Agentic Workflow Automation - Replaces brittle scripts with an agent that classifies, scores, and routes tasks, adapting when processes change.
• Agentic Workflow Graphs - Coordinates multiple agents through directed graphs with looping, branching, and sequential pipelines.
• Agent Team Orchestration - Coordinates several specialized agents that work together to accomplish a complex task.
• Comprehensive Agent Policy Enforcement - Implements guardrails, human approval gates, and policy handlers to validate agent actions before execution.
• Unified Provider Interfaces - Connects to models from Amazon, Anthropic, OpenAI, and others through a single unified interface for agent execution.
• Conversation History Management - Manages conversation history with token-aware retention and summarization to stay within context limits.
• Sliding Window Truncation - Implements automatic sliding-window truncation to keep long-running conversations within token limits.
• Conversational Voice AI - Maintains persistent streaming audio conversations where users can speak, interrupt, and receive real-time voice responses.
• Function-Based Tool Definitions - Defines agent tools using standard Python functions with docstring and signature for model understanding.
• Agent-as-Tool Wrapping - Wraps a full agent instance as a callable tool for nesting within another agent's workflow.
• Human Approval - Interrupts an agent before it performs a sensitive action and waits for a person to approve or reject the step.
• LLM Provider Integrations - Extends an abstract Model class to connect any LLM service, handling request formatting, response streaming, and configuration management.
• Streaming Tool Call Handlers - Processes tool-use events within streaming responses, formatting tool specifications and results for the model.
• Unsafe Tool Call Blockers - Inspects tool inputs before execution and cancels calls that violate defined policies, returning corrective guidance.
• Model Parameter Configurations - Sets inference options such as token limit, temperature, and streaming mode when initializing a hosted model.
• Runtime Provider Switching - Configures an agent to use any supported model provider by swapping the model object.
• Model Response Streaming - Streams model output incrementally with automatic fallback to non-streaming for unsupported models.
• Multi-Agent Orchestration - Orchestrates several agents through swarms, graphs, or agent-to-agent protocols to solve complex tasks together.
• Multi-Agent Orchestration Frameworks - Coordinates multiple agents through swarms, graphs, and pipelines to solve complex tasks collaboratively.
• Multi-Agent Orchestrators - Orchestrates multiple specialized agents through pipelines, graphs, and swarms to solve complex tasks.
• Multi-step Goal Execution - Runs a cycle of model invocation, tool execution, and result feedback to solve tasks requiring multiple steps.
• Multimodal Agent Capabilities - Provides a unified framework for building agents that process and generate text, images, and audio.
• Agent Response Streams - Streams agent responses token by token for real-time display before the full reply is ready.
• Message Format Converters - Translates internal message and tool schemas into the format expected by each third-party model API.
• Agent Prompt Processors - Processes user input through a model that decides tool usage, executes them, and produces a final response.
• Text Generation - Sends a prompt to a model and returns the generated text output.
• Provider Abstraction Layers - Unifies access to models from OpenAI, Anthropic, Google, Amazon, and custom endpoints through a single interface.
• Provider-Agnostic Model Interfaces - Unifies diverse LLM providers behind a single abstract interface with request formatting and streaming.
• Tool Call Interception Middleware - Intercepts tool calls before they run to block unsafe actions or enforce business rules with corrective feedback.
• OpenAI Model Integrations - Connects an agent to any OpenAI or OpenAI-compatible model by configuring model ID and inference parameters.
• Conversational State Preservation - Preserves conversation history and execution state across interactions for coherent long-running sessions.
• Bidirectional Agent Streams - Creates voice or text agents that stream audio and text bidirectionally for conversational interactions.
• Policy-Guided Inspections - Inspects tool inputs against rules before execution, blocking unsafe calls and returning corrective feedback.
• Agent SDKs - Provides an open-source Python SDK for building and orchestrating production AI agents.
• Agent Session Persistence - Stores conversation history and state across sessions so the agent can recall past interactions.
• Tool Function Registrations - Wraps Python or TypeScript functions as callable tools with automatic schema inference and validation.
• Agent Lifecycle Management - Provides lifecycle management for streaming agents, including start, stop, and graceful shutdown via a tool.
• Bidirectional Audio Streaming - Maintains persistent real-time audio or text connections with interruption handling and continuous responses.
• Agent Action Policies - Checks agent actions against rules before execution and provides corrective feedback when a step violates policy.
• Event-Driven Hook Systems - Attaches prioritized callbacks to internal agent events for observation, validation, or modification.
• Agent Misuse Protections - Restricts tool permissions, validates user inputs, and sanitizes outputs to protect against misuse.
• Provider-Agnostic LLM Routing - Switches between model providers such as OpenAI, Anthropic, and Google without changing agent code.
• Bidirectional Streams - Maintains persistent real-time audio or text connections with simultaneous input and output and interruption handling.
• Concurrent Invocation Guards - Rejects concurrent invocations on the same agent instance to protect conversation history from corruption.
• Agent Knowledge Bases - Queries stored knowledge bases to answer user questions with relevant context.
• Knowledge Base Retrieval - Links agents to external data sources so they can retrieve relevant context during conversations.
• File Manipulations - Provides an agent with the ability to read, write, and manipulate files on the local system.
• Dynamic Configuration Updates - Changes model parameters such as temperature or model ID while the agent is running.
• Agent Loop Cancellations - Halts an active agent loop from outside via a signal, discarding partial output and skipping pending tool executions.
• MCP Server Connections - Integrates a Model Context Protocol server as a tool source for agent invocation.
• Model Context Protocol Integrations - Connects agents to external tools and data sources using the Model Context Protocol standard.
• Model Configuration Management - Updates and retrieves model settings during execution, enabling dynamic reconfiguration through tools.
• Context Window Management - Manages when conversation history exceeds the model's context window by reducing verbosity or simplifying schemas.
• Generation Parameter Configurations - Adjusts generation settings such as token limit, temperature, top-p, and streaming to control response behavior.
• Built-In Tool Configurations - Attaches Google's native tools like Search and Code Execution to an agent alongside custom function tools.
• Knowledge Retrieval Sources - Connects agents to external data sources so they can answer questions from stored knowledge bases.
• Long Context Processing - Processes documents up to one million tokens in a single context for summarization and analysis of lengthy texts.
• Sliding Window Managers - Optimizes memory and context window usage with a sliding window to handle long-running conversations.
• Sliding-Window Truncations - Keeps conversation history within a token budget by automatically discarding older turns.
• Local LLM API Servers - Connects to a local server to run AI agents using locally hosted quantized models for inference.
• Anthropic - Configures an Anthropic LLM with API key, model ID, and parameters to power agent conversations.
• Cohere - Configures an OpenAI-compatible client to use Cohere's API endpoint and model identifiers for agent execution.
• Gemini - Configures an agent to use Google's Gemini models for reasoning, code generation, and creative tasks via the provider's API.
• Mistral - Configures the Mistral AI provider with API key, model ID, and client settings for agent inference.
• Runtime Adjustments - Updates model parameters such as temperature, max tokens, and streaming mode while the agent is running.
• Real-Time Streaming - Runs bidirectional real-time audio and text conversations with interruption handling and continuous input.
• Structured Output Generators - Passes a schema to the agent so the model returns validated, structured data conforming to that schema.
• Structured Output Generators - Generates responses that conform to a predefined schema, ensuring type-safe and validated output from the agent.
• Prompt Caching - Reuses cached system prompts, tools, and messages across requests to reduce latency and token costs.
• Expiring Prompt Caches - Caches system prompts, tools, and messages to reduce token usage and latency, with automatic expiration after inactivity.
• Multimodal Prompting - Sends multimodal content such as images or audio alongside text to compatible models.
• Output Constraint Engines - Restricts model output to tokens that follow a user-defined GBNF grammar rule.
• Structured Output Proxies - Returns agent responses as typed Pydantic objects by proxying structured output requests to the underlying model provider.
• Reasoning Step Outputs - Enables models to output detailed reasoning steps alongside their final response for transparent decision-making.
• Conversation State Snapshots - Captures the agent's messages, state, and conversation manager state for later restoration.
• Tool Call Chains - Connects several tool calls together so a single request classifies, scores, and routes data through a process.
• Pydantic Extraction from Agent Responses - Returns a Pydantic model instance parsed from the agent's response for type-safe data extraction.
• Structured Data Extraction - Defines a typed schema and passes it to the agent, which uses the model's native tool calling to return validated, structured data.
• Vision Analysis - Enables agents to extract descriptions, text, and objects from image data using vision capabilities.
• Domain Specific Agents - Runs conversational or autonomous agents using domain-specific models for tasks like finance, healthcare, or creative work.
• Local LLM Execution - Connects to a locally-hosted server and uses its models for text generation, image understanding, and tool calling.
• Agent Execution Traces - Traces every agent decision and exposes hooks to intercept, log, validate, or redirect any step.
• Agent State Snapshots - Captures the agent's full conversation and execution state as an in-memory snapshot for later restoration.
• Pydantic Schema Outputs - Returns responses that conform to a Pydantic model schema, ensuring consistent and validated data from the agent.
• Execution Event Iterators - Yields processing events as an async iterator for real-time observation of intermediate steps.
• LLM JSON Constraints - Forces model responses to match a Pydantic schema by using the server's native JSON validation parameter.
• Response Caching - Reuses parts of previous requests across providers to reduce token usage and lower response latency.
• Agent Event Hooks - Attaches prioritized callbacks to internal agent events for observation or extension.
• Production-Ready Agent Scaffolders - Sets up agents with explicit production-ready settings instead of relying on default configurations.
• Agent Typed Outputs - Returns agent results as typed objects or schemas instead of raw text for predictable downstream processing.
• AWS Bedrock Integrations - Connects to Amazon Bedrock's managed foundation models through a unified API with minimal configuration.
• Structured Output Generations - Returns model responses that conform to a user-defined schema by converting it to Bedrock's tool specification format.
• Tool Directory Loaders - Automatically discovers and loads tool definitions from a local directory without manual registration.
• Tool and Prompt Caching - Reuses cached system prompts, tools, and messages across requests to reduce latency and cost.
• API Integrations - Connects to Meta-hosted Llama API endpoints to run inference without managing your own infrastructure.
• AI Agent Serverless Runtimes - Ships a serverless runtime for deploying and scaling AI agents without managing infrastructure.
• Tool Access Controls - Controls which tools an agent can use by specifying an explicit list and disabling automatic tool loading.
• Output Guardrails - Configures safety and compliance filters on model outputs using a guardrail system.
• Model Safety Filters - Applies configurable safety policies that redact sensitive input or output and returns custom messages when triggered.
• Streaming - Provides a runtime for bidirectional real-time audio and text conversations with interruption handling.
• LLM Structured Output Generators - Produces validated, schema-conforming responses using Pydantic models and native tool calling.
• Agent - Sets limits on loop iterations, output tokens, or total tokens per invocation to prevent runaway execution.
• Agent Observability - Traces agent decisions, monitors performance metrics, and exports telemetry for production observability.
• Agent Performance Monitoring - Monitors tool execution metrics, token usage, response times, and error rates for cost and reliability optimization.
• Agent Telemetry Exporters - Sends telemetry data to monitor agent performance, errors, and usage in production environments.
• Scenario-Based Evaluators - Ships a pre-deployment testing system that validates agent behavior against predefined scenarios with configurable evaluators.
• Cloud Storage Input References - Ships a capability to accept multimodal input via cloud storage references, not just byte data.
• Agent Frameworks - Model-agnostic agent framework with deep AWS integrations.

Istoric stele