Agent Tools

Agent Tools

Tools are what make agents powerful. They let an AI assistant go beyond conversation and actually take action — sending emails, querying databases, creating tickets, and more. ThinkFleet supports four categories of tools.

Tool Categories

Category	Description	Latency
Built-in MCP Tools	Pre-built services (email, web scraping, database)	~50ms
Flow Tools	Your ThinkFleet flows exposed as callable tools	~200ms+
Piece Tools	Individual piece actions (Slack, GitHub, etc.)	~100ms
External MCP Servers	Third-party MCP-compatible servers	Varies

Built-in MCP Tools

Built-in tools are native services that ThinkFleet provides out of the box. They execute as direct API calls, making them the fastest tool type.

Available Built-in Services

Email

Provides email operations across Gmail and Outlook. ThinkFleet automatically detects which provider to use based on your connected account.

Tool	Description
email_search	Search emails by query, sender, date range
email_get	Get full email content by ID
email_send	Send a new email
email_reply	Reply to an existing email thread

Web Scraping

Fetches and extracts content from web pages.

Tool	Description
web_scrape	Fetch a URL and extract structured content
web_search	Search the web and return results

Database

Query your project's database directly.

Tool	Description
db_query	Execute a read-only SQL query
db_list_tables	List available tables
db_describe_table	Get table schema

Configuring Built-in Tools

1. In agent settings, go to the Tools tab
2. Under Built-in Services, toggle the services you want
3. For services that need authentication (like Email), connect an account
4. Connectionless services (like Database, Web Scraping) work immediately

Provider Abstraction

Built-in tools use a provider abstraction layer. For example, the Email service has:

• Gmail Provider — Uses the Gmail API
• Outlook Provider — Uses the Microsoft Graph API

When your agent calls email_search, ThinkFleet routes to the correct provider based on the connected account. Your system prompt doesn't need to mention Gmail or Outlook specifically.

Flow Tools

Any published flow can be exposed as an agent tool. When the agent calls the tool, ThinkFleet executes the flow and returns the result.

How Flow Tools Work

1. You create and publish a flow with a trigger
2. You add the flow as a tool in agent settings
3. The agent sees the flow as a callable function
4. When called, ThinkFleet runs the flow with the provided inputs
5. The flow's output is returned to the agent

Example: Order Lookup Flow as Tool

Flow: "Look Up Order"

• Trigger: receives orderId
• Step 1: Query database for order
• Step 2: Format order details

Tool definition the agent sees:

{
  "name": "look_up_order",
  "description": "Look up an order by ID and return its details",
  "parameters": {
    "orderId": {
      "type": "string",
      "description": "The order ID to look up"
    }
  }
}

Agent usage: When a user asks "What's the status of order #1234?", the agent calls look_up_order({ orderId: "1234" }) and includes the result in its response.

Best Practices for Flow Tools

1. Name flows descriptively — The flow name becomes the tool name
2. Define clear trigger inputs — These become the tool's parameters
3. Return structured data — JSON output is easier for the LLM to interpret
4. Keep flows focused — One flow = one capability. Don't make a flow that does everything.
5. Add descriptions — Customize the tool description to help the LLM know when to use it

Piece Tools

Piece tools expose individual piece actions directly to the agent without creating a flow.

Adding Piece Tools

1. Go to the MCP section in ThinkFleet
2. Navigate to the Pieces tab
3. Search for a piece (e.g., "Slack")
4. Click Add All to add all actions, or select individual ones
5. Connect an account for the piece

Per-Piece Tool Examples

Slack:

• slack_send_message — Send a message to a channel
• slack_create_channel — Create a new channel
• slack_list_channels — List channels in the workspace

GitHub:

• github_create_issue — Create a new issue
• github_create_pull_request — Open a pull request
• github_list_repositories — List repositories

Google Sheets:

• sheets_read_rows — Read rows from a spreadsheet
• sheets_append_row — Add a row to a spreadsheet
• sheets_update_row — Update an existing row

Piece Tool Connections

Each piece tool uses a connection you configure. The agent doesn't need to handle authentication — ThinkFleet injects the credentials at execution time.

External MCP Servers

ThinkFleet supports the Model Context Protocol (MCP) for connecting to external tool servers. This lets you expand your agent's capabilities with third-party tools.

Adding an MCP Server

1. Go to MCP > Services tab
2. Click Add Server
3. Enter the server details:
   • Name: Display name
   • URL: The MCP server endpoint
   • Authentication: API key, Bearer token, or none
4. ThinkFleet discovers available tools from the server automatically

Featured MCP Servers

ThinkFleet includes templates for popular MCP servers:

Server	Description
Playwright MCP	Browser automation — navigate, click, fill forms, take screenshots
File System MCP	Read and write files on a configured directory
Database MCP	Query external databases

Custom MCP Servers

You can build your own MCP server using the MCP SDK and connect it to ThinkFleet. This is useful for exposing internal APIs or proprietary systems as agent tools.

Tool Prioritization

When an agent has access to multiple tools that could handle a request, ThinkFleet uses this priority:

1. Built-in tools — Preferred for speed and reliability
2. Piece tools — Direct piece action execution
3. Flow tools — Full flow execution
4. External MCP tools — Third-party servers

The agent's LLM ultimately decides which tool to call based on the tool descriptions and the user's request. The prioritization above applies when there are equivalent tools from different sources.

Tool Limits

Limit	Default
Max tools per agent	128
Max tool calls per turn	20
Tool execution timeout	30 seconds
Max response size per tool	1 MB

Monitoring Tool Usage

In the agent's conversation history, you can see:

• Which tools were called
• What parameters were passed
• The tool's response
• How long execution took

This is invaluable for debugging agent behavior and optimizing tool configurations.

Next Steps

• Set up agent memory
• Build multi-agent crews
• Learn about MCP