Most agentic workflows are just while loops with vibes

Each week I see a new “autonomous agent” demo in my feed, and each week it seems to be the same thing: a loop that calls an LLM, does not check anything important, and runs until the API key screams.

We need to talk about this. Because most of what people are calling "agentic workflows" are just while loops with vibes.

The Pattern Is Everywhere

You've seen the code. Maybe you've written it. I know I have.

It appears as shown in the image below:

while not done:
    result = call_llm(context)
    context = update_context(result)
    done = result.is_acceptable()  # narrator: most of the time, it's not

That seems_good_enough function is doing a lot of heavy lifting. In most repos I've poked through, it's either a hardcoded iteration cap or another LLM call asking "are we done yet?" Sometimes it's literally just max_retries -= 1.

That doesn't sound like an agent. It's more like a billing reminder with a ticking clock. 🔥

Why This Matters Right Now

The hype around agentic coding is intense. People are building "autonomous" systems that refactor code, write tests, and deploy features without human input. The promise is amazing.

The truth is more mundane. Token spend is on the rise everywhere and most of it is from agent loops with no clear, “done” condition. They spin. They retry. They rephrase the same prompt in hopes that the new answer will be the one that satisfies the prompt.

The Exit Condition Is the Whole Point

Here's the thing nobody wants to hear: the hard part of building an agent isn't the loop. What's difficult is to determine when the loop needs to stop.

→ A code-writing agent needs to know what "correct" means — tests pass, types check, linter is clean
→ A research agent needs to know what "sufficient" means — not "keep Googling forever"
→ A planning agent needs to know what "done" means — an actionable plan, not an infinite refinement spiral

If your exit strategy relies on the LLM declaring that it has finished, then well done, you've left the design of your system up to a token predictor with no understanding of what it means to be finished.

The Bar Should Be Higher

I'm not saying agents are fake. Real agentic systems exist and they're genuinely useful.

But they share one trait: crisp, verifiable exit conditions that don't depend on the model's self-assessment. Think tool-use results you can programmatically validate. You want external state changes that you can measure. You want explicit claims, not feelings.

What sets an agent apart from a while loop is accountability. An agent is aware of its success, while a while loop is only aware of running out of retries.

A Quick Gut Check

Before sending out your next agent, question yourself on three fronts:

→ Can I write a unit test for my exit condition without mocking the LLM?
→ If I removed the iteration cap, would this loop ever stop on its own?
→ Can I explain to a non-technical person what "done" means for this workflow?

If you answered no to any of those questions, then you don't have an agent. You have an expensive loop! Which is fine, loops are useful, just don't put "autonomous" in the paper. 😅

The Uncomfortable Truth

We are currently at a stage where the sample itself is the final product. It's simple to launch and raise funds based on a looping LLM call that creates impressive output in a screen recording.

Production is a whole other beast. Production means your agent is running at 3 AM and there is no one there to see if it got a little stuck and ate up your entire monthly token budget because it just kept trying to work on iteration two.

If you can't define your exit condition, you didn't build an agent. You built a billing event.

The most effective agent code I have seen consists mostly of mundane constructs like conditionals, validators, and state machines, with an LLM hidden somewhere inside them, and not the other way around. The smarts are not in the loop, but in the ability to get out of it. 🧠

So here's my question: What's the most creative exit condition you've built into an agent workflow — one that doesn't just ask the model "are we done?"

You have great ideas that I'd love to use.