Here is a rule I wish someone had told me before I spent six months debugging slow agents: if a task takes a competent human 5 minutes, your agent should complete it in under 30 seconds.
Not eventually. Not after two follow-ups. In one shot, cleanly, the first time.
This sounds obvious. It is not obvious in practice. Most agent implementations I have seen — including my own early ones — violate this rule constantly. And the violations are almost never about AI capability. The model is smart enough. The failures are architectural.
What Triggered This Rule
Six months into running 23 agents across five businesses, I started tracking task completion times. Not wall-clock time — model time. How long from task assignment to clean completion?
Some tasks that should have taken seconds were taking minutes. Simple things: "check if this invoice number matches the one in the email thread," "draft a one-paragraph acknowledgement," "look up what we decided about supplier payment terms."
The agents were not failing these tasks. They were completing them, eventually, but with unnecessary back-and-forth, wrong tool choices, and excessive confirmation requests. A human would have knocked them out in five minutes flat. The agents were taking four to six conversational turns.
That is a problem — not because the tasks were urgent, but because every unnecessary turn burns tokens, adds latency, and breaks flow. At scale, it compounds into something that makes agents feel unreliable even when they are technically correct.
Three Failure Modes
1. Over-engineering the approach
Agents love to plan. Given a task like "find out if we received payment from Client X this month," a poorly configured agent will:
- Acknowledge the task
- Ask what date range to check
- Propose three possible approaches
- Wait for input
- Then execute
A well-configured agent will:
- Check the email archive for payment notifications from Client X
- Check the accounting system if access is available
- Return a one-sentence answer
The difference is not intelligence. It is instruction. Agents that are told to be thorough often become thorough in the wrong direction — they are thorough about their process rather than thorough about the outcome.
The fix: tell agents explicitly to act first, explain if needed. Not "here is my plan" — just do it.
2. Wrong tool choice
This one is subtle. Agents pick the tool they know best, not the tool best suited to the task.
I had an agent that, given any question involving files, would default to reading the entire file and reasoning over the content. For a 50-line config file, fine. For a 2,000-line log file where it needed to find three lines, this was catastrophic — it would burn the entire context window, slow to a crawl, and sometimes fail to extract the answer.
The right tool was grep. Always had been. But the agent was not reaching for grep because it was not configured to default to precise CLI tools over broad file reads.
Fix: maintain a tool priority hierarchy. For text search: grep/ripgrep before full-file read. For structured data: query before scan. For status checks: API call before manual inspection. Write this into the agent's operating instructions.
## Tool Priority (fastest to slowest)
1. Pre-built scripts (scripts/ directory — check MANIFEST.md first)
2. Targeted CLI commands (grep, jq, curl)
3. Partial file reads with offset/limit
4. Full file reads
5. Browser automation (last resort)
3. Excessive confirmation requests
This is the most annoying failure mode because it looks like caution but is actually avoidance.
"Should I proceed?" "Just to confirm, you want me to X?" "I can do this, but wanted to check first."
Some confirmation is appropriate — before sending emails, before destructive operations, before anything public-facing. Most confirmation requests are not that. They are an agent offloading decision-making back to the operator because it was not given clear enough authority.
The fix is explicit authority grants in the system prompt. Not vague permission — specific categories:
## Authority
Act without confirmation for:
- Reading any file in the workspace
- Running read-only CLI commands
- Searching the web
- Writing draft files (not sending)
- Updating memory files
Always confirm before:
- Sending any external message (email, Telegram, etc.)
- Running commands that modify system state
- Anything involving money or legal commitments
Once agents have clear authority boundaries, the "should I proceed" reflex drops sharply.
The Structural Fix: Pre-Built Scripts
The biggest single improvement to agent task speed was building a library of pre-built scripts for common operations.
Instead of an agent figuring out from scratch how to check email for payment confirmations, there is a script: scripts/check-payment-status.sh. It takes a client name, checks the right sources, returns a clean answer. The agent calls it.
Instead of an agent composing a curl command to query our internal API, there is scripts/query-api.sh. It handles auth, retries, and output formatting.
I maintain a MANIFEST.md in the scripts directory:
# scripts/MANIFEST.md
## Available Scripts
- check-payment-status.sh <client> — Returns payment status for current month
- query-api.sh <endpoint> [params] — Authenticated API query with retry
- send-slack.sh <channel> <message> — Post to Slack channel
- email-search.sh <account> <query> — Search email archive
- invoice-lookup.sh <number> — Find invoice by number across all systems
Agents are instructed to check MANIFEST.md before trying to do something from scratch. This alone cut average task completion time by roughly 60%.
Measuring It
Once I had a baseline, I started measuring. Each agent logs task start and completion timestamps. At the end of each day, I can see which tasks are repeatedly slow.
Slow tasks fall into three buckets:
- Wrong tool (fix: update tool priority rules)
- Missing script (fix: build the script)
- Unclear authority (fix: update authority grants)
Almost nothing is slow because the AI is not smart enough. The model is fine. The scaffolding is the bottleneck.
The 30-Second Target
Not every task can hit 30 seconds. Some things genuinely require multi-step processing. But most operational tasks — the bread and butter of a business agent — should clear in under a minute with proper tooling.
When a task is slow, I now ask three questions:
- Is there a script for this that the agent is not using?
- Is the agent picking the wrong tool?
- Is the agent asking for permission it already has?
Ninety percent of the time, one of those three is the answer.
Agents are fast when they are set up to be fast. That setup is your job, not the model's. Build the scripts, define the tool priority, grant the authority — and get out of the way.
Top comments (0)