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; the ones canceling projects — Gartner expects over 40% dead 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, 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 and orchestration being the real 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.