There's a counterintuitive rule in AI agent design that most people discover too late:
Fewer tools = better agent.
This seems wrong. More capability should mean more power, right? But in practice, tool overload is one of the most common causes of AI agent failure.
The Combinatorics Problem
When your agent has N tools available, the number of possible two-tool combinations is N×(N-1)/2.
- 5 tools: 10 possible two-tool combinations
- 10 tools: 45 combinations
- 20 tools: 190 combinations
Your agent has to reason through every relevant combination to decide what to do. More tools means more cognitive load, more reasoning errors, and more hallucination risk.
I've seen agents with 20+ tools spend 3 full reasoning cycles just figuring out which two tools to chain — then pick wrong anyway.
The 5-Tool Stack
The most reliable agent configs I've reviewed use some version of this minimal stack:
- read — consume information (files, APIs, web)
- write — persist information (files, databases, logs)
- search — find information it doesn't have
- execute — run code or commands
- escalate — hand off to a human or another agent
That's it. Everything else is either redundant or a specialization of one of these five.
Why Minimalism Works
Sharper Judgment
When your agent has 5 choices instead of 20, it makes faster, more accurate decisions. The reasoning path is shorter. The error surface is smaller.
Cheaper Runs
Tool-selection reasoning is expensive. Cutting tools from 20 to 5 can reduce per-run token costs by 30-40% just from the decision overhead.
Easier Debugging
When something goes wrong with a 5-tool agent, there are 10 possible two-step action paths. With a 20-tool agent, there are 190. Debugging 20-tool agents is a nightmare.
Better Composability
Five clean tools compose well with each other. Twenty overlapping tools create ambiguity — should the agent use file_read or document_load? When tools overlap, agents pick arbitrarily.
The Audit Question
For every tool in your agent's config, ask:
"Is this tool doing something that read, write, search, execute, or escalate can't do?"
If the answer is no — remove it.
If the answer is yes — it belongs. But if you find more than 8-10 tools surviving this audit, your tool definitions are probably too narrow.
The Specialization Exception
Some agents need domain-specific tools: send_email, charge_payment, run_sql. That's fine — these are genuine specializations that go beyond the generic five.
But even then, keep the total count as low as possible. If you can generalize send_email and send_slack_message into a single notify tool, do it.
Real Numbers
One agent config we reviewed went from 18 tools to 6. Results:
- Token cost per run: down 41%
- Error rate: down 67%
- Average reasoning steps: down from 4.2 to 2.1
- Time to debug failures: down ~80%
The agent didn't lose capability. It gained reliability.
Start Minimal, Add With Justification
The right approach to agent tooling is the same as API design: start with the minimum viable set, then add tools only when there's a clear, documented need.
"It might be useful" is not a justification. "We need to do X and none of the existing tools can" is.
If you want to see tool configs for agents that handle real workloads, the Library at askpatrick.co has battle-tested examples — updated based on what's actually working in production.
The boring truth about AI agents: constraints make them better.
Top comments (0)