Most AI agents are too eager

  • ai
  • agents
  • tooling

I’ve been building a lot of agent-style workflows lately — things that take a task, break it into steps, execute those steps, and report back. The usual loop. And the pattern I keep landing on is counterintuitive: the best agents are the ones that wait.

The eagerness problem

The default behavior of most agent setups is to be maximally proactive. You give it a task, it immediately starts decomposing it, making tool calls, generating outputs. It wants to be done. And for simple tasks, this is fine. “Summarize this document” doesn’t need a lot of deliberation.

But for anything with real ambiguity — “figure out why this deploy failed” or “draft a plan for migrating this service” — eagerness is a liability. The agent starts executing before it understands the problem. It picks the first plausible path and commits hard. When that path turns out to be wrong, it either doubles down or starts over from scratch.

Sound familiar? It’s the same failure mode junior engineers have. Not because they’re bad, but because they haven’t learned that pausing to think is itself productive work.

What waiting looks like

In practice, “waiting” means a few things:

  • Gathering context before acting. Instead of immediately trying to fix a bug, the agent reads the relevant files, checks recent commits, looks at the error logs. Not because I told it to do each of those things, but because the system prompt says “understand before you act.”
  • Asking clarifying questions. This is the one that took me longest to accept. I kept wanting fully autonomous agents that never interrupt me. But the agents that ask “did you mean X or Y?” before doing 30 minutes of work in the wrong direction are just… better.
  • Checkpointing. After completing a meaningful step, pausing to verify the result before moving on. Did the test pass? Did the output match expectations? This isn’t overhead — it’s the thing that keeps a 5-step workflow from going off the rails at step 2.

The patience tax

The obvious downside is speed. A patient agent is slower than an eager one. If you’re measuring agent performance by time-to-completion on a benchmark, the eager agent wins every time. But if you’re measuring by “how often do I have to throw away the output and start over,” patience wins by a mile.

I’ve started thinking about it as a tax. You pay a small upfront cost in latency for a massive reduction in rework. For my workflows, the math isn’t even close — the patient approach is faster end-to-end because it almost never produces garbage.

The meta-lesson

The weird thing is that this applies to how I work too. The projects where I rush to code before thinking are the ones that end up taking the longest. The ones where I spend 20 minutes staring at the problem before writing a line of code tend to go smoothly.

Maybe the reason eager agents annoy me is that they’re a mirror. But at least I can fix the agent’s behavior with a system prompt. My own eagerness remains a work in progress.