Loop Engineering: Real Progress or Token Farming?
Agentic loops are real progress when they have goals, validation, and stopping rules, but they can become token burn when iteration is the default.
Why AI companies keep asking models to think harder, and who really benefits?
If you use AI tools regularly, you may have noticed a quiet shift in how they work.
The model no longer just answers.
It thinks in rounds. It plans, executes, reviews, revises, tests, and tries again before showing you the final result.
OpenAI Codex has `/goals` for long-running tasks. Anthropic Claude has `/workflow` for setting a direction and letting agents run longer-horizon work. Different names, same direction: give the AI a high-level goal, reduce the need for constant steering, and let the system figure out the steps.
This is powerful.
For complex work like coding, research, debugging, planning, or multi-step execution, this kind of loop can produce much better results. A good agent can enter plan mode before acting, revise the plan before execution, check its own work, run tests, validate output, and stop only when the exit criteria are met.
That is not a gimmick. That is real progress.
But there is a practical question worth asking.
Who actually has the luxury to run AI this way all day?
Inside LLM companies, long-running loops are normal. The people building these systems live in an environment where letting agents think, retry, compare, validate, and continue for longer periods is part of the product development process. Compute is the cost of exploration.
But for the public and for most businesses, every loop has a cost.
Every extra planning pass costs tokens. Every revision costs tokens. Every validation step costs tokens. Every "agent continues working" moment has an economic consequence, whether it shows up directly in API usage, subscription limits, latency, or infrastructure cost.
This is where the tension begins.
Loop engineering is useful when the task genuinely benefits from iteration. But if looping becomes the default for everything, then users may slowly be trained to accept higher token burn as the normal price of quality.
The uncomfortable question is:
Are long-running agent workflows being sold as productivity, while also normalizing more token consumption?
The answer is not simple.
For hard tasks, looping is exactly what we want. If an agent is writing code, it should plan before editing. It should check the files. It should run tests. It should inspect failures. It should revise. It should stop only when the work is actually done.
That is engineering.
But for simple tasks, the same behavior can become wasteful. A factual lookup does not need a long horizon. A simple rewrite does not need multiple agent passes. A direct question does not always need planning, critique, and validation.
The difference is not whether the AI loops.
The difference is whether the loop has a purpose.
A good loop has four things:
- A clear goal
- A plan before execution
- A validation method
- A stopping condition
Without those, the loop becomes motion without accountability. The output may look more thoughtful, but the user may simply be paying for more internal activity.
This is where incentives matter.
Model providers benefit when agents think longer. Users benefit when agents finish efficiently.
Those two incentives are not always aligned.
This does not mean `/goals`, `/workflow`, or agentic long-horizon tools are bad. They may become one of the most important shifts in how we use AI. The ability to give a system a direction and let it work through the details is genuinely valuable.
But the next level of AI adoption will require more discipline from users and builders.
We need to ask:
- Does this task really need a loop?
- What should the agent check before continuing?
- What counts as done?
- When should the agent stop?
- Is the quality gain worth the token cost?
The real skill going forward will not be prompting harder.
It will be knowing when to use a simple answer, when to use a loop, and when to let an agent run with a clear contract.
Because the best AI workflow is not the one that thinks the longest.
It is the one that knows what progress looks like, and stops when it gets there.