Cerebras: Why Looping Agents Can't Do Without Verifiers

Jun 24 2026

Loops are the least surprising thing to happen all year. They are obvious, they have existed for years, and the underlying trick is not new. AutoGPT, BabyAGI, Ralph loops, auto-research scripts, and every janky bash loop with a retry condition were already pointing at the same shape.

In March 2023, AutoGPT took a goal, decomposed it into subtasks, and looped until it decided it was done. It became one of the fastest-growing repos in GitHub history, then almost immediately turned into a cautionary tale about autonomy without verification. Early loops wandered, hallucinated, repeated itself, and occasionally set your OpenAI bill on fire. BabyAGI followed weeks later and hit the same wall: long-running agents compound small errors, lose the plot, and confuse motion for progress.

Ralph loops revived the idea with more discipline by bringing tests, builds, and external checks into the loop. In that sense, Codex’s/goal and Claude Code’s/loop are not magical new primitives, but are old loops wrapped in a better interface, pointed at better verification.

So why are loops becoming popular now? For years, the AI was a brain with no body: it could plan, retry, and narrate, but it could not reliably see what happened after it acted. Then several things landed close enough together to make a classic engineer sit up and mutter, with real spiritual fatigue, “it’s so over for me.”

But fine, yes, what is a loop? A loop is a repeated cycle where an agent autonomously takes actions until it hits a verifiable goal, or until you stop it. The keyword isn't autonomous and it isn't AI . It's verifiable . The heart of building a good and effective loop is verification.

Old verification was mostly textual and binary: did the test pass, did the benchmark clear the bar, did the judge-model approve? That was clean, but it only covered tasks that could be flattened into strings. The new frontier is verification for work that used to require a human pair of eyes:

Here’s an example of a loop with visual feedback for verification that does not require a human to sit there supervising every pass. My goal is to take an image of a real object and turn it into structured CAD instructions for the 3D printer, effectively cloning the object from a photo . In this case, I used Gemma 4, Google’s latest open model, running on Cerebras .

In this run, every Gemma 4 loop produced a new STEP file in about 1.2 seconds, running at roughly 1,500 tokens per second. That is fast enough for the agent to treat iteration as cheap instead of precious.

Let’s break down the loops prompt that I used:

That’s a lot of words, but we can build up your intuition so you can /loop effectively!

Here is my starting image and initial Gemma 4 prompt, as well as what Gemma 4 created on the first pass.

Here’s the Gemma 4 prompt and 3D rendering output that my loop independently created roughly five loop iterations later.

and here’s a timelapse of the 3D printer creating the dumbbell: the print is smooth, structurally sound, and looks nice.

The part worth noticing is that the loop rewrote its own prompt to get there. It looked at the render, saw what was missing, and revised the instructions five times without me. That same look-compare-fix cycle doesn't care what it's pointed at. Now, context lengths are so long and verifiers are so good that you can have it work against an objective on the order of complexity of cloning entire web apps.

But we still have a ways to go. A loop is only as good as the goal you hand it, and there are two ways to hand it a bad one.

Spiralling is the symptom of a broken loop. With no definite end state, the loop has no way to know it's finished, so it keeps "improving" in circles while the token meter runs. Verification is a strong solution, where you want to keep the loop on track so that you are not wasting tokens and are still completing your goal efficiently.

Cheating is a prompting problem, and a slipperier one. Vague prompts will get gamed. Different models cheat differently and some follow instructions better than others, but the fix is always the same:

For example, a vague prompt like

could result in the checkout test passing, but a previously fixed bug getting reverted. Instead, a better prompt might be:

Another example is training a model to perform well on a benchmark. A simple prompt like:

A smart, sneaky model might download Terminal-Bench and train on the benchmark itself. The score goes up while the actual capability does not. A better prompt explicitly marks the eval set as radioactive:

Off-limits: you may not train on Terminal-bench benchmark, generate benchmark-derived data, or touch the eval set in any way.

While the workflow isn’t new, this moment is. It is undeniably strange and exciting to go to sleep while five production-grade apps are being built by loops that can see, act, check, and try again.

Agents now have eyes, tools, verifiable end states, and enough speed to run a hundred runs before morning. All that’s left is for you to go build one.

Performance comparisons are based on third-party benchmarking or internal testing. Observed inference speed improvements versus GPU-based systems may vary depending on workload, configuration, date and models being tested.

1237 E. Arques Ave Sunnyvale, CA 94085