What are AI agent tools? 9 types, examples and how to choose

• What a tool is: An AI agent tool is a defined function that lets a language model read from or act on an outside system, and targeted tool calls keep long, noisy context out of the prompt.
• Nine categories: Agent tools fall into web search and extraction, RAG retrieval, code execution, databases, communication, browsers, observability, memory, and security.
• Platforms by job: Firecrawl covers the web, and Firecrawl Alexandria adds third-party data providers. Composio, Zapier MCP, Pipedream Connect and Merge Agent Handler connect SaaS apps. E2B runs code, Cerbos sets permissions, and Mastra hosts the agent.
• Design: Unambiguous parameter names, error messages that explain the fix, and a ReAct or plan-and-execute loop decide whether an agent picks the right tool.
• Evaluation: Measure tool selection accuracy, latency, cost per task and failure modes before you scale an agent to production.

Back in 1969, Doug Engelbart demonstrated the computer mouse, hypertext, and networked collaboration in what's now called "The Mother of All Demos."

The presentation showed new tools that completely changed how humans interact with computers. Before the mouse, using a computer required memorizing complex commands. Afterward, everyone could point and click.

AI agents are at the same moment. A language model without tools is like a brilliant analyst locked in a room with no phone, no internet, and no way to verify anything. It can reason about what it knows, but it can't check current facts, run calculations, or take any action beyond generating text.

Traditional software, on the other hand, follows deterministic patterns where getWeather("NYC") executes the same way every time with no reasoning involved. AI agent tools connect these deterministic functions with non-deterministic reasoning systems that might call that same function with different parameters, at unexpected moments, or combined with other tools in unexpected sequences.

A tool is a defined capability that allows a language model to execute operations and retrieve information from external systems. I know that's a mouthful so let me simplify.

Consider the question "Should I bring an umbrella today in Tokyo?"

Without tools, an agent would respond: "Based on general climate patterns, Tokyo typically experiences rain during June and September. I'd recommend checking a weather service for current conditions, as I don't have access to real-time data."

With a weather tool, the same agent responds: "Yes, bring an umbrella. Tokyo currently has scattered showers with an 80% chance of rain continuing through the afternoon. The temperature is 18°C with winds at 15 km/h."

The difference is one agent speculates based on outdated training data and the other can retrieve current information and provide actionable answers.

Language models have limited context windows, and even the most expansive models face performance degradation when overloaded with information. As highlighted in the "Lost in the Middle" research by Liu et al., models struggle to retrieve information buried in the center of long contexts.

Consider asking a model to find a specific phone number from a list of 10,000 contacts. If you include that entire contact list in a prompt, the language model has to read every entry, wasting its context window and driving up API costs. This method is fundamentally inefficient and slow.

Tools solve this through intelligent querying. Instead of loading all customer data into a prompt, you provide a search_customers tool that returns only relevant matches. The agent describes what it needs, the tool performs efficient lookups, and only useful results consume context. This is the core reason why modern RAG tech stacks prioritize targeted retrieval over massive context injection.

I’ve divided agent tools into nine categories based on the specific capabilities they provide. Understanding these patterns helps identify which tools are most appropriate for a given use case. The platform comparison after this list maps real products to each category.

Web tools give agents access to current information beyond their training data. A web search tool discovers relevant sources, while an extraction tool fetches specific pages and returns clean, usable content. For a comparison of the leading options, see the guide to search tools for AI agents.

Every agent needs these capabilities to ground their responses in recent facts but building a scraping infrastructure is quite complex. Websites change, information is rarely structured or simple to scrape. Firecrawl’s specialized web search APIs handle extraction complexity so agents receive clean Markdown or structured JSON. For instance, if you’re building a travel planning agent, Firecrawl can fetch flight information directly from airline websites.

This category also includes specialized scraping: product monitoring across e-commerce sites, news aggregation across publications, and research gathering from academic sources.

For agents that should be notified when pages or sites change, Firecrawl's /monitor lets you describe what to watch in plain English and sends a signed webhook when something meaningful changes. Because unchanged pages and noisy diffs do not trigger notifications, agents only need to process meaningful changes, cutting tokens up to 90%. See the full announcement of Firecrawl's web monitoring for AI agents for setup examples and use cases.

Read more here.

Retrieval tools connect agents to internal knowledge, such as company policies or support tickets that aren't on the public internet. This relies on Retrieval-Augmented Generation, where documents are converted into vector embeddings and stored in a database.

Before documents reach that embedding step, they need to be collected, cleaned, and structured. That's the AI data preparation stage, and it's where most RAG systems quietly fail when skipped or done poorly.

Effective retrieval tools return context selectively using semantic search to find relevant passages. Instead of dumping a whole document, a well-designed tool returns only the key policy statement and the surrounding context. This provides enough info for an accurate answer without wasting tokens.

Code execution tools let agents write and run programs for tasks requiring computation. Instead of attempting complex math in text, agents generate Python code, execute it in sandboxed environments, and use the results. This category includes code interpreters for calculations and data analysis, development tools that interact with version control, and data processing tools that handle large datasets.

In my experience, production implementations must use sandboxed environments to isolate agent-generated code from sensitive systems. You define boundaries around file access, network requests, and execution timeouts. Apart from that, returning actionable error messages like "The function expects a list but received a string" gives a clear solution to help agents self-correct without human intervention.

Database tools allow agents to query structured data without loading entire datasets. An agent helping with customer analytics might query for users who signed up last month but haven't made a purchase. Here the agent receives a question, generates a SQL query, executes it, and formats results.

When integrating these agent tools, make sure your production systems explicitly use read-only connections and validate all parameters to prevent data leakage. The goal is to provide useful access while maintaining strict data integrity.

Communication tools connect agents to collaboration platforms like Slack, Teams, or email. Calendar tools check availability, and task tools create tickets or assign work.

These tools often consolidate complex operations into single workflows. For example, the n8n competitor monitoring workflow we created demonstrates this. It scrapes a site, compares versions, and sends a Gmail notification when changes occur. Context enrichment, like attaching relevant documents to a meeting invite, makes these tools significantly more effective. For a broader evaluation of the platforms, see the guide to AI workflow automation tools.

Browser automation allows agents to interact with websites through clicking and form-filling like a human would. This automation is flexible, but it is also fragile and slower than API calls. Interfaces change, which means you need to invest time in creating new scripts or burning tokens to let agents figure it out every time.

Read our guide on the best browser agents for AI automation.

But for government forms, legacy internal tools, and third-party services without APIs, it's often the only viable option.

For all other use cases, Firecrawl reduces the need for browser automation by extracting clean data programmatically. In my experience building these systems, this approach eliminates about 80% of the cases where you'd otherwise need browser automation.

LLM observability tools provide a window into what agents are actually doing. Logging records every tool call and parameter, while tracing shows the reasoning steps leading to an answer.

Detailed logging is the only way to debug emergent agent behavior. When agents fail mysteriously or produce unexpected results, you need to understand their decision process and this category becomes extremely important. As noted in the Anthropic guide on tool evaluation, tracking accuracy, runtime, token consumption, and tool errors is the best way to reveal patterns like redundant tool calls.

Memory tools allow agents to remember information across conversations. Short-term memory stores context from the current conversation. The agent remembers what you discussed five minutes ago. Long-term memory persists across sessions, storing facts like preferred programming languages or ongoing project details.

To keep memory efficient, you need agent memory tools that use retrieval to fetch only the relevant memories based on the current topic of discussion. For example, if a user asks for a code review, the agent should only retrieve past coding preferences.

Security tools enforce boundaries around agent actions. Permission systems verify whether an agent has the right to perform a requested task based on the user's role and context and policy enforcement ensures behavior complies with business rules and regulations.

Autonomous systems can have real-world consequences, so it’s always best to implement multiple layers of protection. This includes authentication, authorization, rate limiting, and audit logging. Policy tools can also enforce spending limits or require human approval for high-risk operations.

This is a rapidly evolving space, so don't be surprised if we see more types of agent tools emerge tomorrow. This list was first written in January 2026 and updated in October 2026.

The best AI agent tools in 2026 are platforms that each cover one job from the categories above. Firecrawl handles web search, scraping and browser interaction, and Firecrawl Alexandria adds third-party data providers. Composio, Zapier MCP, Pipedream Connect and Merge Agent Handler connect agents to SaaS accounts. E2B runs agent code, Cerbos sets permissions, and Mastra hosts the agent.

Pick by the job, and expect to combine two or three. The table maps each platform to the tool categories above, with entry pricing checked on each vendor's site on Oct 27, 2026.

The catalog sizes use different units (toolkits, apps, APIs), so they describe each product's scope and can't be ranked against each other.

Firecrawl gives AI agents the live web through one API. Search finds fresh sources, Scrape turns any URL into Markdown or JSON, and Interact clicks through dynamic pages in a real browser. For teams that have it enabled, Firecrawl Alexandria extends the same API key to third-party data providers and Firecrawl's own indexes, so one integration covers both web pages and structured provider data.

Agents call Firecrawl through the API and SDKs, the Firecrawl MCP server, or the CLI. The endpoints run in this order of use: /search, /scrape and /interact first, then Crawl and Map for whole sites, /agent for structured data gathered across many pages, and /monitor for change alerts.

Firecrawl Alexandria reaches data that doesn't live on public web pages. A catalog query on Oct 27, 2026 returned 32 data categories, from package registries and app stores to sports results, government programs and research papers. Discovering tools costs nothing. Running one costs the credit price listed on that tool. To see prices before calling, pass includeCosts: true to the firecrawl_find_tools MCP tool, or add --include-costs to firecrawl find-tools in the CLI. Some providers ask an org admin to accept their terms before the first call. Our guide to the API for AI agents compares that one-key model with wiring up each provider's API separately.

# Find matching data tools alongside web results (discovery is free)
firecrawl search "podcast conversations about AI agents" --sources web,alexandria --domain-tools --limit 2

To try the web side without signing up, point any MCP client at https://mcp.firecrawl.dev/v2/mcp or run npx firecrawl-cli@latest. Keyless access is free and capped per IP address per day. The keyless MCP endpoint exposes Search, Scrape and Parse, and the CLI and SDKs add Interact. A free API key raises those limits with 1,000 credits a month. Firecrawl Alexandria needs an API key on a team where Alexandria is enabled.

Composio, Zapier MCP, Pipedream Connect and Merge Agent Handler connect AI agents to apps that a user or company already has accounts in, such as Gmail, Slack or a CRM. Each one stores and refreshes OAuth tokens per user, so the agent acts with that user's permissions rather than one shared key.

Composio lists 1,500+ toolkits and runs the OAuth flow for each connected account, with the option to bring your own OAuth app. Agents reach it through its SDK or MCP. The Hobby plan includes 100,000 tool calls a month. Pro costs $29 a month, and tool calls past the free amount bill at $0.0003 each. Our guide to OAuth for AI agents compares its auth model with eight others.

Zapier MCP exposes Zapier's 9,000+ app connections to MCP clients such as Claude, ChatGPT and Cursor. It comes with every Zapier plan, and each tool call uses two tasks from the account's existing quota. Teams that already run Zaps can reuse those connections without new setup.

Pipedream Connect offers 10,000+ tools across 3,000+ APIs through one remote MCP endpoint, with managed auth per user. When no prebuilt tool covers an endpoint, Pipedream can send a raw request to that API with the user's credentials attached. Development is free with no credit card, and production needs a paid plan.

Merge Agent Handler groups its connectors into tool packs that scope which tools an agent can call, and it keeps an audit trail of every tool call. Each tool call spends credits from the plan. The free plan has 2,000 credits a month, and Pro is $1,000 a month for 25,000 credits.

Several of these also run as standalone servers in our list of the best MCP servers.

E2B runs agent-written code in isolated cloud sandboxes, which covers category 3 without exposing your own servers. An agent starts a sandbox through E2B's SDK, runs code inside it, and reads back the output. The Hobby tier gives a $100 one-time usage credit, with sessions up to one hour and 20 concurrent sandboxes.

Pro costs $150 a month plus usage billed by the second. It allows 24-hour sessions and 100 concurrent sandboxes, expandable to 1,100.

Cerbos is an authorization layer that checks agent and MCP tool requests against policies you define before they run. It logs every decision with who acted, what they did, when, and which policy applied, which gives category 9 an audit trail across human and agent identities. Revoking an agent's access is a policy change.

The policy decision point is open source. Cerbos Hub, the managed control plane, is free for a proof of concept up to 100 monthly active principals. Development plans start at $25 a month and Production at $933 a month. Merge Agent Handler and Composio also apply rules to tool calls, which can be enough for a small set of agents.

Mastra is a TypeScript framework and hosted platform for building and running the agent itself, so it sits underneath the tool platforms above. It handles agents, workflows, memory and observability. Its MCP client lets a Mastra agent call tools from any MCP server, including Firecrawl's.

Mastra can also expose its own agents and tools as an MCP server. The framework is Apache 2.0 licensed and free to self-host. The hosted Starter plan is $0 with 100,000 observability events and 24 CPU hours, and Teams is $250 a month. The Mastra tutorial shows a Mastra agent using Firecrawl for search and scraping, and our roundup of the best AI agent frameworks covers code-first alternatives.

No-code AI agent builders such as n8n, Gumloop and Lindy package a model, tools and a visual workflow editor into one product. They suit teams that want a working agent without writing code. In n8n, for example, Firecrawl and any MCP server can be added as workflow steps.

Builders sit one level above the platforms in this guide. The agent is assembled in the builder, and the platforms supply the tools it calls. The workflow automation roundup linked under category 5 compares them in depth.

Start from what the agent has to reach, then add layers only when a workflow needs them:

• The agent needs current facts or third-party data: start with Firecrawl for the web and Firecrawl Alexandria for data providers.
• It acts inside users' SaaS accounts: use Composio or Pipedream Connect for products with many end users, and Zapier MCP when the connections already exist in Zapier.
• You need tool scoping and audit logs on SaaS calls: Merge Agent Handler builds both in.
• It writes and runs code: add E2B so that code never runs on your own servers.
• It handles regulated data or high-impact actions: put Cerbos in front of the tools.
• You're still choosing where the agent runs: evaluate Mastra or another framework first.

As Anthropic's research on writing effective tools for agents explains, building effective tools means designing for systems that interpret descriptions, reason about when capabilities apply, and handle errors differently than humans would. Building such agent tools requires attention to interfaces, error handling, and performance characteristics.

Well-designed interfaces make it obvious what the tool does, what inputs it needs, and what results it returns.

Vague descriptions like "processes data" don't provide enough information for a model to use them correctly. Instead, I prefer specific descriptions like "searches customer databases by email and returns name and total purchases."

Parameter definitions must also be explicit. Instead of user, use user_id or user_email_address. Ambiguous names cause agents to guess the format incorrectly about 30% of the time in my experience. Clear JSON schemas provide the formal specifications needed to reduce these errors.

Error messages should guide an agent toward a solution. Instead of returning a raw error code, return a message like "The 'date' parameter must be in ISO 8601 format (YYYY-MM-DD). You provided '01/15/2024'."

Only about 20% of the agent implementations I’ve reviewed include this level of detail, yet it drastically improves reliability. Such clear messages also improve the model’s ability to self-correct when something goes wrong and reduce the amount of human oversight required to complete tasks.

Because models will retry operations or repeat tool calls while problem-solving, your tools must handle these patterns gracefully. Idempotent operations produce the same result when called multiple times with identical parameters. If an agent creates a document and immediately retries with the same parameters, return the existing document or safely indicate it already exists.

Rate limiting is also necessary to protect infrastructure from runaway agents. When an agent hits a limit, the tool should explain the restriction and when it can try again. To avoid overspending on tokens, set token limits on responses. For example, return the first 20 results and explain how to refine the search.

Performance characteristics determine whether tools are practical for production use.

Caching reduces both latency and cost for frequently requested data. When agents repeatedly query the same information, caching returns results instantly instead of hitting databases or APIs.

Token efficiency in responses is also necessary as returning verbose outputs wastes tokens, increases generation latency, and raises processing costs.

Source

How an agent orchestrates its tools matters as much as the tools themselves. Different tasks require different logic for sequencing actions.

• Single-step tool use: The simplest pattern is single-step execution, where an agent calls one tool to answer a direct question, like "What is the current price of Bitcoin?" This works well for simple lookups but fails when a task requires multiple pieces of information.
• Plan-and-execute: In this architecture, the agent creates a complete plan before taking any action. For a task like "Compare the market position of our top three competitors," the agent identifies the competitors, gathers data, and then synthesizes it. This works best for well-defined problems but can be rigid if the initial plan is flawed.
• ReAct loops: ReAct (Reasoning and Acting) is an iterative pattern that alternates between thinking and acting. The agent takes an action, observes the result, and then reasons about what to do next. You can build a ReAct agent with LangGraph to see this in action. I find the Thought → Action → Observation pattern elegant because it mirrors human problem-solving. It is particularly effective for exploratory tasks like debugging or open-ended research. Each observation informs the next step, allowing the agent to adapt as it learns.
• Multi-agent collaboration: Some tasks are too complex for one agent. Multi-agent systems, such as those built with the Google Agent Development Kit or CrewAI’s agent framework, divide labor among specialized agents. A "flights agent" and an "accommodations agent" can work together under a "host agent" to plan a trip.
• Human-in-the-loop escalations. Production agents need the ability to escalate to a human when they face uncertainty or high-stakes decisions. Rather than respond with a "I don't know,” the agent should explain what information they have, what's missing, and what options they've considered. The Open Researcher agent we built demonstrates how agents can reason through complex research tasks autonomously.

You can't improve what you don’t measure. Over the last couple of months building agent systems, one of the most valuable lessons for me has been about establishing systematic evaluation before scaling production usage.

The Anthropic research on writing effective tools shows that even small refinements to tool descriptions can yield dramatic improvements.

Most real-world agents need to interact with websites. Whether you're researching competitors, monitoring prices, or gathering information for analysis, the web contains vast amounts of useful data trapped in HTML, JavaScript, and dynamic content designed for human viewing.

Firecrawl solves the operational challenges with scraping and fetching data from the web and turning it into parsable outputs. Here’s how it fits into an agent toolbelt.

For a real-world example of an agent using Firecrawl’s full toolbelt, see the OpenClaw + Firecrawl guide and the 16 best OpenClaw skills for extending your agent’s capabilities.

Explore how we built eight n8n web scraping workflows with Firecrawl that solve real business problems here.

Websites are built for humans, full of navigation menus and ads that clutter an agent's context window. Firecrawl solves this by converting web pages to markdown for AI.

Instead of parsing HTML yourself, you provide a URL and receive formatted content with clutter removed. The platform offers endpoints for each job: scraping single pages, crawling entire websites, gathering structured data across many pages with Firecrawl's /agent, and handling dynamic JavaScript content.

Raw text extraction isn't always enough. Many use cases require structured data that agents can use directly.

Consider a travel deal finder that compares flight prices across airlines. Firecrawl's structured extraction returns pricing, availability, and booking links as JSON with defined schemas, making it trivial for agents to compare options. This structured extraction makes it possible to build content generation pipelines and product intelligence systems with Firecrawl.

Scraping at scale means handling JavaScript rendering, rate limits, retries, and site redesigns.

In Firecrawl's scrape coverage benchmark of 1,000 public URLs (January 2026), Firecrawl returned the core page text for 96% of them. That leaves agents with usable data and little cleanup. This allows you to build deep research agents and AI chatbots with web context that operate reliably without needing a dedicated scraping infrastructure team. For a complete look at how web search for agents and deep research retrieval patterns wire into production stacks, see the dedicated guide.