---
title: "Overview"
description: "Understanding Tools in Agentic Systems."
icon: "globe"
---

Tools are the most important component of any Agentic system. In this guide, we'll cover the basics: what tools are, key characteristics, and the three primary ways you can build or import your own tools.

## Key Principles of Building Effective Tools

Here are the key principles for building effective tools:

<CardGroup cols={3}>
  <Card
    title="Standalone"
    icon="cube"
  >
    Tools should run independently with minimal dependencies on other tools or agents. Any agent should be able to use any tool without extra re-prompting.
  </Card>

  <Card
    title="Configurable"
    icon="gear"
  >
    Tools should expose adjustable parameters. The agent should be able to tune modes, thresholds, timeouts, limits, etc to better fit the environment or the task at hand.
  </Card>

  <Card
    title="Composable"
    icon="hammer"
  >
    Outputs of one tool should match the inputs of another tool. They should allow the agent to compose them into workflows autonomously, instead of pre-defined sequences.
  </Card>
</CardGroup>

## What are Tools?

**At a high level, tools represent the capabilities that your agents have.**

Tools enable your agents to perform specific tasks necessary to fulfill their designated roles. For instance, just as a real virtual assistant can search the web or send emails, the virtual assistant agent can be equipped with similar tools.

Below are some more examples of tools:

- **FileWriter:** A tool that allows an agent to write code or text to a file.
- **CommandExecutor:** A tool that allows an agent to execute terminal commands.
- **LeadUpdater:** A tool that allows an agent to update a lead in a CRM.
- **LinkedInProfileScraper:** A tool that allows an agent to scrape a LinkedIn profile.
- **FacebookAdCreator:** A tool that allows an agent to create a Facebook ad.


<Tip>

By themselves, each of these tools is not very useful, however in combination with each other, they allow agents to perform a much wider range of tasks.

For example, `FileWriter` tool by itself can allow the developer agent to write code, however, in combination with the `CommandExecutor` tool, it can also run and test its own code, which instantly makes it more powerful. (We'll cover the key characteristics of tools in a bit.)
</Tip>
**At a low level, tools are essentially just code.**

Whatever the tool you are creating, at the lowest level, it always comes down to code. The only difference is where this code is being executed. For instance, if you are making an API call, it will primarily be executed in the cloud, and if it's a file system tool, it will be executed on the same machine where the agent is running. **Even if you are using a no-code platform to build your tools, like n8n or zapier, at the lowest level, it all still comes down to code.**

This means that agentic systems are much more similar to traditional software programs than you might think...

<img className="block dark:hidden" src="/images/agents-vs-programs-light.png" alt="Tools Diagram" />
<img className="hidden dark:block" src="/images/agents-vs-programs.png" alt="Tools Diagram" />

Just as in a standard program, we have functions that are executed in a loop, in an agentic system, we have tools that are executed by your agents.

And what this allows you to do, is tackle significantly more complex tasks. Tasks where there are so many possible paths that you can't hard code all of the possible conditional logic in advance.

Now, that we understand what tools are, let's cover how you can build your own tools.


## Built-in Tools

Agency Swarm ships with several ready-to-use tools:

- **IPythonInterpreter** - Execute Python code in an isolated environment
- **PersistentShellTool** - Run shell commands with persistent state
- **LoadFileAttachment** - Load and process local files (images, PDFs)

```python
from agency_swarm import IPythonInterpreter, PersistentShellTool, LoadFileAttachment
```

[Learn more about built-in tools →](/core-framework/tools/built-in-tools)

## 3 Ways to Build Tools

When it comes to building your own tools, you have 3 primary options:

<CardGroup cols={3}>

  <Card
    title="Custom Tools"
    icon="hammer"
    href="./custom-tools"
  >
    Build your own completely custom tools from scratch. (Recommended)
  </Card>

  <Card
    title="OpenAPI Schemas"
    icon="file-code"
    href="./openapi-schemas"
  >
    Use public OpenAPI schemas and convert them into tools.
  </Card>

  <Card
    title="MCP Integration"
    icon="plug"
    href="./mcp-integration"
  >
    Connect to MCP servers for advanced capabilities.
  </Card>

</CardGroup>

**It is recommended to start with custom tools**, as they give you the most flexibility and control. Even if you are connecting to external APIs, we still recommend creating custom tools, as they allow you to have more control over the tool's outputs.

Click on the card of your choice to learn more about each one.
