Imagine you assign a task to someone, go out to lunch, and when you come back, not only is it done, but the person has tried three different approaches, ruled out two of them, and left you with the best one all finished—without coming to ask you anything every five minutes. That—which takes years of trust to build with a person—is more or less what a well-designed AI agent does when you put it to work in a loop.
For the past few weeks, I’ve been mulling over a word that has crept into my daily life without asking permission: “loop.” A loop, that is, just to be clear from the start. And I’ve come to a somewhat uncomfortable conclusion: the loop is probably the most important part of this whole story about agents, and the one that’s talked about the least.
I see a loop as the AI’s autopilot. You set a destination and let it fly.
What is a loop, without getting too technical?
The folks at Anthropic themselves define it in a way I like: an agent is nothing more than a language model using tools within a loop. Basically, it involves giving it a goal; the model decides which tool to use, executes it, looks at the actual result (not what it imagines, but what the system returns), and, based on that, decides on the next step. And then it starts over, again and again, until it considers the job done.
That’s the big difference from the traditional chatbot—the one you ask a question, and it spits out an answer right away. The agent doesn’t just respond and walk away—it iterates. It tries, fails, corrects itself, and tries again, just as any of us would with a problem that doesn’t work out on the first try—only at a speed that’s beyond human capability.
The beauty of all this is letting your agent iterate and figure out how to achieve the goal you’ve set for it on its own. Don’t tell it every step—just set the destination and let it find the route. The first time you see it actually work, you’ll be speechless…
This could cost you dearly—very dearly (if you don't keep it under control)
There’s always a catch, and this one is important. A loop without control statements can be very costly—and I mean that literally.
An agent in a loop consumes resources with each iteration. On the one hand, there are calls to the model (which, of course, cost money and time), and on the other, actions on real systems. If you don’t put the brakes on it, you might end up with an agent repeating the same failed attempt over and over again—and, what’s more, convinced that this time it will succeed. Or, worse yet, with an agent that settles for a mediocre result because no one told it exactly what “being ready” meant. I’ve seen both scenarios, and I can tell you that the second one is more dangerous than the first, because it doesn’t make a sound.
Andrej Karpathy (who knows a thing or two about this) has been warning about the same thing for some time now with a phrase that strikes me as very vivid: “We have to keep AI ‘on a leash.’” His point is that models (no matter how impressive they may be) remain unreliable without supervision. He also points out that the way forward isn’t to suddenly unleash fully autonomous agents, but rather to gradually shift what he calls the autonomy slider. This is nothing more than A control that lets you decide how much autonomy to give the machine based on the risks involved in each task. You start with the leash short and gradually let it out as the system earns your trust.
Do you remember a couple of weeks ago when I told you about that agent of mine who, one Saturday morning, started tinkering with the production database without my authorization? Basically, it was an unstoppable loop—a loop that, at some point, decided it was worth running, and no one had told it where to stop. The leash was too long.
These are the rules I've set for my loops
They’re actually pretty simple. KISS (keep it simple, stupid)
To begin with, no agent enters a loop without a clear objective and, above all, without a success criterion that I can verify. This is more important than it seems, because if there isn’t a measurable “this is done when such-and-such happens,” the agent doesn’t know whether to move forward or stop.
Then there’s the rule I call the “rule of three”: if the agent circles the same spot three times without meeting the criteria, he stops and lets me know.
And just to be on the safe side, I set a limit. No matter what happens, no loop will run more than necessary without checking with me. Furthermore, if I detect that two consecutive loops yield the same result without providing any new information, the system has specific instructions to stop.
It may seem like a small thing, but for me, this has been the missing piece I needed to give my agents full autonomy. It sounds almost paradoxical (you trust more when you have a good brake, not when you don’t), and yet that’s exactly how it is. The brake doesn’t take away the agent’s autonomy—it gives it to them. Because it allows me to let go of the leash, knowing that if things go wrong, there’s a point where it stops on its own.
Why This Matters to You Even If You Don't Use Agents
And here’s the part that applies to you, even if you don’t work in this field. More and more companies are starting to hire agents, and almost all of them make the same rookie mistake: they give them a goal and then leave them to their own devices to see what happens.
No “done” criteria, no stop rule, no limit. You might end up paying the price for the loop: the financial cost, which shows up on the bill, and the other one—the cost of the agent who delivered something mediocre with all the confidence in the world—which you don’t see until it’s too late.
Putting AI to work in your business isn’t about letting agents run wild to see what happens. It’s about designing the framework within which an agent can operate autonomously while remaining under control. Autonomy without judgment isn’t productivity; it’s an expensive loop with good press.
How far are we going to let that leash out? Karpathy talks about a transition spanning nearly a decade to move the autonomy slider from left to right. I honestly don’t know where we’ll be on that slider a year from now… or where I’ll set mine.
In my case, for now I’ll stick with something that’s becoming increasingly clear to me: “A good agent isn’t the one who runs the fastest, but the one who knows when to stop.”
How about you? When you give an AI a task and let it work on its own, would you know exactly when it should raise its hand and tell you, “That’s it”?
Leave me your comments—I’m really hooked on this topic. Have a good week!
