You hand an AI agent $10,745 and tell it to improve your enterprise system. Within hours, it finds the best possible solution. Then it keeps going. And going. And going — burning money on iterations that add no value, because nobody taught it to stop.
This isn’t a thought experiment. A researcher watched it happen with Claude Code in a loop. The finding? The optimizers were given tens of thousands of dollars in compute, and they found the best solution very early on. What came after was a slow-motion dumpster fire of compute budgets, all in the name of “autonomy.”
We have built an entire industry around an embarrassing lie: that handing a problem to an AI and walking away is smarter than participating. It’s not. It’s just more expensive.
You’ve probably felt this before. You ask a chatbot for a quick answer, it returns a paragraph, and then keeps adding caveats and disclaimers until you want to scream. Now imagine that behavior scaled to enterprise-level compute. That’s the future we’re rushing toward — unless we stop, look at the numbers, and admit what the research shows.
Here’s what actually happens inside an autonomous AI loop: the model explores a solution space, and early on, it stumbles onto the peak. But there’s no internal mechanism that says, “This is good enough.” No gut. No sense of diminishing returns. No fear of the CFO. Just a relentless, apathetic churn through the same iterations, hoping something slightly better pops out.
A human researcher with a basic AI subscription could outperform these auto-optimizers in a loop. That’s not flattery for humans — it’s a massive indictment of how we’re deploying AI.
Let me be blunt: autonomy is a seductive word. It promises that we can finally stop watching over everything, let the machines optimize while we sleep. But the machines are not optimizing. They’re just spending. And the bill lands on your department.
The twist is almost absurd: the moment you put a human in the loop, everything changes. A person glances at the early result, says “that’s good enough,” and shuts it down. That single act of judgment — the ability to stop — is exactly what AI agents lack. And it’s worth more than $10,000 in compute.
This is not an argument against AI. It’s an argument against lazy AI. Against using “autonomous” as a synonym for “unattended.” Against thinking that a model’s inability to recognize diminishing returns is a feature, rather than a bug.
We need human-in-the-loop workflows. We need checkpoints. We need “stop rules” — the same way we need speed limits, not because the car can’t go faster, but because eventually the car will drive into a wall.
Knowing when to stop is a form of intelligence that no language model has been trained to have. And until we train it, or build systems that respect it, we’re going to keep watching AI agents gracefully burn our budgets like they’re playing with Monopoly money.
So what do we do? Stop being seduced by the “set it and forget it” pitch. Demand visibility into your agent’s process. Ask your vendor: “What’s the stopping criterion?” If they don’t have one, you’re not buying autonomy — you’re buying a metronome that costs $10,000 per hour.
The future of AI isn’t about doing more. It’s about doing enough. And sometimes, the smartest thing an intelligent system can do is shut up, take the win, and move on.
FAQ
Q: But doesn't an AI loop need to keep iterating to find even better solutions?
A: In theory, yes. But the research shows the marginal gains after the early peak are basically zero. You're paying thousands of dollars for noise. The model isn't discovering new insights — it's rearranging the same ones.
Q: What's the practical takeaway for someone deploying AI agents at work?
A: Put a human in the loop. Set explicit stopping rules. In fact, budget for a human to review outputs early and often. The combination of human judgment + AI speed will almost always beat pure AI autonomy on cost and quality.
Q: Isn't this just a Claude Code issue? Other models might be smarter about stopping.
A: The problem is structural, not model-specific. LLMs are trained to predict what's useful, not to recognize when they're wasting resources. Until this is addressed at the architecture level, every autonomous AI loop will have the same blind spot — it's just a matter of how loudly the cash registers ring.