Honestly it's not a new concept. this feature already existed in models before. problem was the models were just weak.
Looping only works if each attempt gets the agent closer to the correct solution. Earlier models weren't consistent enough for that. They often misunderstood feedback, repeated the same mistakes, or got stuck in an infinite loop. Instead of improving with each iteration, they frequently failed to make meaningful progress, eventually consuming large numbers of tokens without solving the problem.
The Context Window Limitation
Earlier language models had much smaller context windows. As the agent went through more iterations, the conversation history and reasoning gradually filled the available context. Once the context window was exceeded, older messages had to be dropped or compressed into summaries. As a result, the agent could forget previous failed attempts, lose important clues or reasoning, and sometimes repeat the same mistakes it had already made.
So what did modern models actually fix?
Bigger context windows Models can now hold way more of the conversation/history without forgetting, so the agent doesn't need to spin up a fresh session every few iterations. it can just keep looping with the full history of what failed and why.
modern models also got way more consistent earlier if you asked a model to fix the same bug 5 times you'd get 5 different half-baked answers, now it actually converges toward the real fix. and tool use got better too . Old models could write code but couldn't run it and read the actual error, now they call a test runner, see the real failure, and fix that exact thing which is literally what makes the "verify" step possible.
And then there's inference it is simply the process of a model generating an answer. like when you type "write a java binary search," the model reads your prompt, thinks, and generates code that whole process is inference. every time the model generates text, that's one inference. now here's the thing inference has gotten way faster and cheaper. running a loop means multiple inferences back to back (generate, verify, retry, repeat), and earlier that would've been slow and expensive enough that nobody did it casually. now it's cheap and fast enough to just run 10 iterations without thinking twice.
I tested this myself
instead of just reading, I tried the smallest version of this loop on a palindrome checker. first attempt used basic s == s[::-1] it worked on simple cases but failed on anything with spaces, punctuation, or mixed case, stuff like "A man a plan a canal Panama." fed that exact failure back in, nothing extra. second attempt cleaned the string first, then compared it passed.
two iterations, one test suite as the verify step. that's the entire loop generate → verify → retry → stop.
try it yourself with literally any model . Ask it to write something small, run it, let it fail on some edge case, copy that exact error and paste it back asking it to fix that specific thing, run it again. watch it fix itself.
that's the whole "loop" everyone's hyping except you're the one doing the looping manually. tools like claude code, openClaw etc just automate this exact cycle so nobody has to copy-paste errors back and forth themselves.
So, going back to my original doubt
why couldn't we just loop an agent till it solves the problem, back in 2022-23? turns out we could, technically. the loop itself was never the hard part it's a while loop.
what was actually hard, and what's finally solved now, is knowing when to stop. bigger context so it doesn't forget, consistency so each attempt gets closer instead of randomly different, real tool use so it can verify instead of guess.
so when people say "loop engineering," they're not describing some new AI capability. they're describing the fact that the boring infrastructure problems finally got solved, so a decade-old idea finally works.
Top comments (0)