Strands Agents Tools: Pre-Built Capabilities for Strands AI Agents

What Strands Agents Tools Provides and Who It Is For

Building an AI agent from scratch requires writing glue code for every external capability the agent needs: reading files, executing commands, searching the web, storing memories, calling APIs. Strands Agents Tools is a catalog of pre-built implementations for all of these tasks, designed to work with the Strands Agents Python framework.

The package is maintained by AWS and listed in pyproject.toml with authors at [email protected] under the Apache-2.0 license. It targets Python developers building agents with the strands-agents framework who want production-grade tool implementations rather than prototype-quality code.

The README attaches an important caveat to the entire catalog: the tools are described as experimental. Many grant agents powerful capabilities, and the README explicitly warns that any production use should be preceded by an independent security review. This applies especially to tools that execute shell commands, run Python code, access the file system, call AWS APIs, connect to external MCP servers, and automate browsers and desktops.

Installing the Package and Optional Extras

The base installation via pip provides most tools with their core dependencies:

pip install strands-agents-tools

Several tools with heavier optional dependencies are gated behind extras. Installing with extras for memory via Mem0, browser automation, RSS feeds, and computer control:

pip install "strands-agents-tools[mem0_memory, use_browser, rss, use_computer]"

For development work, the repository provides a virtual environment setup:

git clone https://github.com/strands-agents/tools.git
cd tools
python3 -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"
pre-commit install

The package requires Python 3.10 or later and depends on strands-agents 1.0.0 or later as its core dependency. Other bundled dependencies include sympy for mathematical tools, pillow for image processing, slack_bolt for Slack integration, rich for terminal output, and prompt_toolkit for interactive features.

Core Tool Categories

The file operations category provides file_read for reading configuration files and code, and file_write for writing results and creating new files. The editor tool, which offered advanced file operations including pattern replacement, is now deprecated per the README.

The memory category covers persistent agent memory across runs. It supports four backends: Mem0, Amazon Bedrock Knowledge Bases, Elasticsearch, and MongoDB Atlas. The choice of backend determines whether memory is local, cloud-hosted, or database-backed.

The web category includes tools for real-time search and page content extraction. The tavily_search and tavily_extract tools are deprecated per the README, though their replacements are listed in the deprecation section.

The Python execution tool, python_repl, runs Python code snippets with state persistence across calls. It includes a user confirmation step before executing code, which the README lists as a safety feature. The shell tool for executing shell commands is also deprecated.

The mathematical tools use the sympy library for symbolic computation, allowing agents to solve equations, simplify expressions, and perform calculus operations rather than relying on numeric approximations.

AWS integration is provided through the aws_requests_auth dependency and a set of tools that give agents direct access to AWS service APIs. The package's pyproject.toml lists botocore as a core dependency, meaning AWS credential configuration applies to any agent that loads the AWS tools.

Agent Composition: Swarm, Agent-as-Tool, and Multi-Agent Graph

Beyond single-agent tools, the catalog includes three capabilities for building multi-agent systems. The swarm intelligence tool coordinates multiple AI agents running in parallel, with shared memory for passing information between agents. The README describes this as suited for parallel problem solving where different agents address different aspects of a task simultaneously.

The agent-as-tool feature allows creating nested agent instances that run as callable tools. An outer agent can invoke an inner agent with model switching: the inner agent runs with a different model than the outer one. The README notes this is useful for specialized sub-tasks where a different model has relevant strengths.

The multi-agent graph tool creates deterministic DAG-based pipelines where outputs from one agent node flow to the next. Each node in the graph can be configured with its own model, and the overall pipeline topology is defined by the DAG structure. This differs from the swarm tool in that the graph is deterministic and sequential at each dependency boundary, while swarm execution is parallel.

All three composition tools come with the experimental label. The agent-as-tool and graph tools require careful design of the inter-agent interface to avoid message format mismatches.

High-Risk Tools: Browser, Computer, and Dynamic MCP Client

Three tools in the catalog carry explicit warnings beyond the general experimental label. The browser tool gives an agent access to a Chromium instance for automated web actions: clicking, form filling, and navigation. The computer tool automates desktop actions including mouse movements, keyboard input, screenshots, and application management. Both tools have direct access to the user's system environment.

The dynamic MCP client tool connects at runtime to external MCP servers and loads their tools into the agent. The README marks this with a caution symbol and the text "use with caution" because connecting to an arbitrary external MCP server and loading its tools means executing code from a third party in the agent's context. The README links to Responsible AI guidance for best practices but leaves the security review to the deploying team.

These three tools demonstrate the breadth of the catalog: an agent using the computer tool can interact with any application on the host machine, while an agent using the dynamic MCP client can acquire new capabilities from any server it connects to. Both are powerful and both require explicit understanding of what the agent is authorized to do before deploying in a production environment.

Limitations and Deprecated Tools

Several tools in the catalog are officially deprecated in the current version. The README marks shell, http_request, tavily_search, tavily_extract, and editor as deprecated and directs users to the deprecations section for replacements. Deprecated tools still work in the current release but will be removed in a future version.

A comparable approach for teams not committed to Strands Agents is to use LangChain's tool ecosystem. LangChain is a Python framework for building AI agents that provides its own set of pre-built tools covering web search, file operations, and API calls. The key difference is that LangChain's tools are designed to work across multiple agent frameworks, while strands-agents-tools is specific to the Strands Agents runtime. LangChain does not include the desktop computer automation tools or the dynamic MCP client that strands-agents-tools provides.

The experimental label across the catalog is a genuine warning rather than a disclaimer. Code execution tools, filesystem access tools, and the computer tool all run with the same system permissions as the agent process. Teams should treat the security review guidance in the README as mandatory rather than advisory before deploying any of the high-capability tools to a production environment.

Editorial conclusion

Strands Agents Tools is appropriate for teams already committed to the Strands Agents framework who want a pre-built tool catalog rather than writing each capability from scratch. The breadth covers most common agent needs, and the pip install path is fast. The critical constraint is the experimental label: the README states this explicitly and lists real security implications for tools that execute code, access the file system, call AWS APIs, or automate browsers and desktops. Production deployments require an independent security review before enabling those tool classes. Teams not yet using Strands Agents should evaluate whether the framework itself meets their needs before adopting this tool catalog.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. README
4. Releases
5. strands-agents/tools on GitHub