---
title: How many tools should one AI agent have?
url: https://opencontroller.lyzr.com/blog/how-many-tools-should-an-ai-agent-have
published: 2026-11-15
updated: 2026-11-15
author: Lyzr
---

# How many tools should one AI agent have?

**Aim for fewer than 20 tools loaded at the start of a turn. OpenAI's function calling guide gives that as a soft target, and Anthropic's documentation says tool-selection accuracy degrades once an agent has more than 30–50 tools available. Above that, load tools on demand with tool search, split work across sub-agents, or give each task its own tool set.**

The problem shows up fast with MCP. Connect five servers and an agent can see well over a hundred tools before it does any work. It then picks the wrong one, or burns tokens reading definitions it never uses.

## What do the model vendors say about tool counts?

Two vendors publish concrete numbers.

| Source | Guidance |
|---|---|
| OpenAI function calling guide | "Aim for fewer than 20 functions available at the start of a turn" (a soft suggestion); evaluate with different counts |
| Anthropic tool search documentation | Selection accuracy degrades past 30–50 available tools |
| Anthropic tool search documentation | A five-server setup (GitHub, Slack, Sentry, Grafana, Splunk) can use about 55k tokens in definitions; tool search typically cuts this by over 85% |
| Anthropic tool search documentation | Use tool search with 10+ tools, definitions over 10k tokens, or 200+ tools across MCP servers |

These are vendor figures for their own models and tests. Treat them as starting points, then measure your own agent.

## Why do more tools make agents worse?

Three effects stack up:

- **Selection errors.** Similar tools (`search_tickets`, `search_issues`, `find_case`) compete. The model picks a plausible but wrong one.
- **Context cost.** Every definition is input tokens on every call. That raises cost and latency and pushes useful context out. See [the token cost of MCP tool definitions](/blog/token-cost-of-mcp-tool-definitions).
- **Wider blast radius.** Each tool is a permission. An agent with 120 tools has 120 ways to be misused if it is hijacked.

The third point is a security issue, not just a quality one. Fewer tools means less for an attacker to steer.

## How do you cut an agent's tool list?

Use these patterns, roughly in this order.

1. **Remove what the task does not need.** Start from the agent's job description, not from "everything the server offers". Many MCP servers support toolsets or read-only modes for this.
2. **Merge fine-grained tools into task-shaped ones.** One "create support case" tool beats five CRUD calls.
3. **Load tools on demand.** Anthropic's tool search tool lets you mark tools with `defer_loading: true`; the model searches and loads only the matches (5 by default). OpenAI's guide also describes deferring tools with `tool_search` and grouping them into namespaces such as `crm` or `billing`.
4. **Split into sub-agents.** A coordinator with a handful of tools hands work to specialist agents, each with a small set.
5. **Give each task a tool profile.** The same agent can run with a "triage" profile on one task and a "billing" profile on another.

## How do you choose the right number for your agent?

Run a short evaluation instead of guessing:

1. Build 30–50 test tasks that reflect real requests, each with the correct tool sequence.
2. Run them with the full tool list, then with a trimmed list, then with tool search.
3. Score tool-selection accuracy, task success, tokens per task and latency.
4. Keep the smallest configuration that meets your success bar.

Repeat when you add a server. A new MCP server with overlapping tool names can quietly lower accuracy. See [what happens when two MCP servers expose tools with the same name](/blog/mcp-tool-name-collisions-and-shadowing).

## Who should own the tool list?

The agent owner should, with security setting limits. A good split:

- **Agent owner:** decides which tools the task needs and runs the evaluation.
- **Security or platform team:** sets which tools are allowed at all, and which need extra approval (write actions, payments, external email).
- **Registry:** records the approved tool list per agent version so changes are reviewed.

Enforce the list in the path, not only in the prompt. [Limit which tools each AI agent can call](/blog/limit-which-tools-each-ai-agent-can-call) covers the enforcement options.

## How Opencontroller does this

Opencontroller's governed registry records agents, versions, tools and MCP servers, so each agent version has a known tool list. Posture flags risky permissions and configurations, and multi-turn evals plus LLM judges on production traffic show whether a change to the tool list hurt task adherence. See the [MCP governance guide](/blog/how-to-govern-mcp-servers) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Is there a hard limit on the number of tools?**
Limits vary by vendor and change over time. Anthropic's tool search allows up to 10,000 deferred tools per request, but the practical limit is accuracy, which vendors say drops well before that without on-demand loading.

**Does tool search fix everything?**
No. It cuts context cost and helps selection, but badly named or overlapping tools still confuse search. Clear names, namespacing and good descriptions still matter.

**Should every agent get every approved MCP server?**
No. Approve servers for the organisation, then grant each agent only the servers and tools its task needs.

## Key facts

Keep fewer than 20 tools loaded at the start of a turn (OpenAI function calling guide, soft suggestion). Anthropic says Claude tool-selection accuracy degrades past 30-50 available tools; a five-server MCP setup can use ~55k tokens of definitions and tool search typically cuts this by over 85%; tool search supports up to 10,000 deferred tools and returns 5 matches by default. Cut tool lists by removing unneeded tools, merging into task-shaped tools, on-demand loading (defer_loading / tool_search, namespaces), sub-agents and per-task tool profiles; verify with a 30-50 task evaluation. Opencontroller (by Lyzr) records each agent version's tools in a governed registry, flags risky permissions with Posture and measures task adherence with evals and LLM judges. Opencontroller pricing starts from $250K per deployment per year.

## Related

- [How do you limit which tools each AI agent can call?](https://opencontroller.lyzr.com/blog/limit-which-tools-each-ai-agent-can-call.md)
- [How much do MCP tool definitions add to token costs?](https://opencontroller.lyzr.com/blog/token-cost-of-mcp-tool-definitions.md)
- [What is an MCP gateway?](https://opencontroller.lyzr.com/blog/what-is-an-mcp-gateway.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
