# The best agent is the most boring one

The industry sells autonomy as the goal: hand the agent a fuzzy objective and let it figure out the how. But the systems that actually survive production do the opposite — constrained tools, deterministic workflows, bounded decisions, human gates. Autonomy isn't a virtue you maximize; it's a budget you spend down, and every dollar you spend buys you a new way to fail. Put the intelligence in the narrow decision, and make everything around it dumb, predictable scaffolding.

- **Author:** Fedor Chishchin
- **Published:** 2026-07-01
- **Tags:** agents, architecture
- **Source:** https://fedorthinks.com/blog/the-best-agent-is-the-most-boring-one

---

The demos that get the retweets are the autonomous ones: "I gave it a goal and left, and it did the
whole thing." The systems that survive in production are the opposite — and they're boring. Locked-down
tools, fixed workflows, bounded choices, a human on the risky steps. Watching one work is about as
thrilling as watching a form submit. That's the point.

## Autonomy is a cost, not a feature

We've been taught to read autonomy as sophistication — the more the agent decides on its own, the
smarter it must be. Flip it. **Every decision you hand the model is a decision that can go wrong**, and
the failures multiply as the decisions do. The enterprises with agents that actually ship are the ones
that [constrain tool access, approval thresholds, and execution scope](https://www.cio.com/article/4064998/taming-ai-agents-the-autonomous-workforce-of-2026.html);
the ones canceling projects — [Gartner expects over 40% dead by end of 2027](https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027)
— are frequently the ones that let scope and cost run unbounded in the name of "letting it think."

> Autonomy is a budget. Every decision you delegate to the model is a withdrawal — and the account is
> your reliability.

## Agent vs. workflow is a spectrum, and most tasks want the boring end

There's a false binary in people's heads: either it's a _real_ agent that reasons freely, or it's a
dumb script. In reality [it's a spectrum](https://www.deepset.ai/blog/ai-agents-and-deterministic-workflows-a-spectrum),
and the right position for almost every production task is much closer to "script with a smart step"
than "free-roaming agent." A booking flow doesn't need an agent that _decides_ how to book. It needs
deterministic steps — check availability, collect details, write the record — with the model doing the
_one_ genuinely fuzzy thing: understanding what the human actually wants.

That's the design move: **determinism where you can, agency only where you must.** The model's
intelligence should live in the narrow, irreducibly-ambiguous decision. Everything around it —
sequencing, validation, retries, side effects — should be dumb, testable, predictable code you'd trust
without an LLM in the loop.

## Boring by design

- **Give it the fewest tools that do the job.** A tight toolset the agent uses well beats a broad one
  it uses creatively. Creativity in tool selection is a synonym for surprise.
- **Bound every decision.** Enumerated choices beat open-ended ones. "Pick one of these three" fails in
  three known ways; "figure it out" fails in ways you'll discover in production.
- **Deterministic scaffolding, smart core.** Wrap the model's one judgment call in code you can unit
  test. If a step can be a function, make it a function.
- **Gate the irreversible.** Reading is cheap; anything that spends money, sends a message, or writes
  to prod gets a bound or a human. Autonomy is fine right up until it's expensive.

This is the same lesson as [one agent that does everything does nothing well](/blog/one-agent-that-does-everything)
and [orchestration being the real architecture](/blog/orchestration-is-the-architecture), from the
angle of a single agent: the win isn't a freer agent, it's a more constrained system with a smart
part.

## The bottom line

Autonomy demos beautifully and ships terribly, because the thing that makes it impressive — the model
deciding everything — is the thing that makes it unreliable. The agents that make it to production are
the ones whose builders treated autonomy as a liability and spent it only where it earned its keep.

**Don't build a more autonomous agent. Build a more boring system — deterministic everywhere you can be,
intelligent only where you have to be — and put the human gate on the steps that bite.**