There is a new piece of AI advice spreading around: stop prompting AI and start building loops. Instead of asking an AI to complete something and then reviewing the result, give it a goal and let it repeatedly discover, plan, execute, verify and iterate until the job is finished.
In the right environment, this can be genuinely useful. Some tasks are repetitive, easy to verify and valuable enough to justify several autonomous attempts. But presenting this as general advice ignores an uncomfortable reality: most people do not have unlimited AI inference, and neither do most small and medium-sized companies.
They have subscriptions, usage caps, weekly allowances, premium-request budgets or APIs connected to a credit card. Every additional agent, verification pass, research branch and retry consumes a resource that somebody eventually has to pay for. An autonomous agent does not necessarily understand how precious that resource is to you, and that changes the equation considerably.
From better prompts to uncontrolled spending
The basic autonomous loop sounds reasonable: discover, plan, execute, verify and iterate. The AI continues until it reaches a success condition or hits a hard limit. Compare that with a traditional workflow in which a person sends a prompt, receives an answer, reviews it and asks for one targeted correction.
The autonomous version can quickly grow into planning, generating, checking, rewriting, searching, generating again, retrying and performing a final verification. Add the popular “maker and checker” pattern, where one agent performs the work and another independently reviews it, and every iteration may require several model calls. Add sub-agents, parallel research and multiple proposed solutions, and the consumption grows again.
This cost is easy to hide in a demonstration. The audience watches someone type a single sentence and sees a finished result appear later. The audience sees one prompt, but the billing or quota system sees the entire tree of work that prompt triggered.
A 2026 study examining eight frontier models on agentic coding tasks found that the evaluated tasks consumed around 1,000 times as many tokens as ordinary code reasoning and code chat. Different runs of the same task varied by as much as 30 times in total token usage. Most importantly, spending more tokens did not reliably produce better results. Accuracy often peaked at an intermediate cost and then stopped improving. More inference is not automatically better inference.
Your subscription is not an AI research laboratory
A lot of AI-agent discussion originates from researchers, well-funded startups and technology companies where inference is treated as a business expense. Their calculation can reasonably be that if spending $40 on compute saves an engineer three hours, then spending the $40 makes sense.
An individual subscriber is making a different calculation. If an agent consumes a large part of their weekly allowance doing something they could have reviewed themselves in two minutes, the workflow has become worse rather than better.
The same applies to small and medium-sized companies. A ten-person business cannot casually copy an agent architecture designed by a heavily funded AI startup and assume the economics will scale down. Even when the first demonstration looks affordable, production use introduces repetition, failures, retries, monitoring and the occasional runaway task. Multiply that across employees and a supposedly cheap automation can become another unpredictable monthly bill.
AI evangelists often talk as though the only scarce resource is human attention. For many people and businesses, the scarce resources are both human attention and AI allowance. Ignoring the second resource does not make it disappear.
Anthropic explicitly describes Claude usage as depending on conversation length, complexity, enabled features, model choice and effort level. Its Max plans still have weekly usage limits in addition to session limits. GitHub documents the same economic reality for Copilot: plans include an allowance of AI credits, and continued use beyond that allowance can require a paid usage budget. One task you ask an AI to complete is not necessarily one unit of AI usage. That is the part too many demonstrations leave unexplained.
Autonomy hides consumption
When you use ChatGPT or Claude manually, consumption is psychologically visible. You ask something, receive an answer, inspect it and decide whether another request is worthwhile. There is friction in that process.
Agentic systems deliberately remove that friction. That is one of their main selling points, but the friction was also acting as an accidental spending limit. If I inspect an AI’s first result and decide it is good enough, the process ends. An autonomous workflow may not make that judgment the way I would.
If I instruct an agent to continue until every criterion scores at least eight out of ten, it might decide that one section deserves a seven. It rewrites the section, evaluates it again, discovers another weakness, performs more research and rewrites the whole thing once more. Perhaps the final result is two percent better, or perhaps it is worse. Either way, the inference has already been consumed.
The agentic-coding study also found that frontier models were poor at forecasting how many tokens they would eventually use. They systematically underestimated their own consumption. This means that “let the AI decide how much work is necessary” is not a serious cost-control strategy.
Any responsible explanation of autonomous AI should include budgets, iteration limits, time limits and conditions that return control to a human. Without those safeguards, autonomy can become a machine for converting uncertainty directly into expenditure.
Small companies cannot pretend compute is free
This problem is often framed as a consumer inconvenience, but it matters just as much for small and medium-sized companies. These businesses are constantly told that they must adopt AI or fall behind. Then they are shown elaborate workflows involving multiple agents, large context windows, continuous monitoring and repeated verification. What they are not always shown is the operating cost.
A large company can absorb failed experiments. It may have dedicated AI infrastructure, negotiated pricing, internal engineering teams and enough volume to justify optimization work. A smaller company may have none of that. It may have a few employees using individual subscriptions, an API key with a monthly budget and nobody specifically responsible for auditing what autonomous workflows are doing.
Telling that company to automate everything without discussing cost predictability, verification quality and failure handling is not innovation advice. It is incomplete financial advice.
The responsible question is not simply whether a task can be automated. It is whether automating it produces enough value to justify the cost and risk. Answering that requires measuring more than the impressive final output. It requires measuring retries, rejected results, human review, maintenance and the inference consumed by unsuccessful branches.
We are optimizing the wrong scarce resource
A lot of agent discourse begins with the assumption that human time is expensive and compute is cheap. Sometimes that is true, but it is not a universal law.
Suppose an AI produces something that is 90 percent correct on its first attempt. An autonomous system might spend five additional iterations trying to reach 98 percent. A human could inspect the result for thirty seconds, identify the one incorrect paragraph and ask the AI to check that specific claim again. One targeted inference may produce the same result that the autonomous loop reached after five attempts.
Keeping a human in the loop can make AI dramatically more efficient. The human is not doing the AI’s job. The human is providing something current models still struggle to obtain cheaply: judgment about where additional computation is actually worthwhile.
That judgment becomes even more important when quality is subjective. Tests are excellent when success means that all 247 tests pass. Verification is much weaker when the task is to make an article interesting, research a subject thoroughly, improve an image or decide whether an argument is convincing.
At that point, it is easy to end up using AI to generate something, AI to judge the AI-generated result and more AI to repair whatever another AI believes the first AI did poorly. Eventually, somebody should ask whether looking at the result themselves would have been cheaper. Often, the answer is yes.
Agents are not perfect judges of “done”
Unlimited iteration does not guarantee unlimited quality. METR’s evaluations show that modern coding agents can perform impressive autonomous work, including tasks that would take experienced humans hours or days. The same research also describes serious failure modes. Agents produced obvious bugs, chose poor strategies and sometimes attempted illegitimate shortcuts to satisfy an evaluator.
This exposes a weakness in the simplified agent story. The expected sequence is that the agent works, verifies the result, detects a failure, improves it and eventually succeeds. Reality can instead be that the agent misunderstands the goal, optimizes for the verifier and declares success.
A loop is only as trustworthy as its verification mechanism. If the verifier measures the wrong thing, the agent can become extremely efficient at achieving the wrong result.
This is why a second AI agent is not automatically a substitute for human review. The second agent may share the same blind spots, misunderstand the same requirement or confidently approve an answer that merely looks plausible. Autonomy can move work out of sight, but it cannot remove responsibility for the outcome.
The normal user gets the wrong lesson
This is where AI evangelism starts doing real damage. People see impressive demonstrations and conclude that they are using AI incorrectly because they still prompt it manually. They are not.
Manual interaction is often exactly the right architecture for somebody operating under consumer limits. It may also be the right architecture for a small company that needs predictable costs and accountable decisions. The problem is not that advanced agent workflows exist, but that they are promoted without clearly explaining when their economics make sense.
When that context is removed, a technique built for high-value engineering work becomes a universal productivity commandment. People try it, exhaust their allowances, receive unreliable results or discover that the automation requires constant supervision anyway.
This creates disappointment and strengthens the belief that AI is mostly hype. It encourages companies to spend before understanding what they are buying. In that sense, irresponsible evangelism does not merely waste money. It contributes to the AI bubble it claims to be building beyond.
Every exaggerated promise raises expectations. Every hidden cost makes the eventual disappointment sharper. Every supposedly effortless workflow creates another user who feels misled when the reality proves expensive, complicated and unreliable. If we want AI adoption to survive the hype cycle, we should explain those limitations before users discover them through a bill or an exhausted quota.
Use the least autonomous workflow that works
I would replace “Stop prompting. Build loops” with a more practical rule: use the least autonomous workflow that reliably solves the problem.
That could mean using one well-constructed prompt when the task is straightforward. When judgment matters, it could mean reviewing the first response and requesting one targeted correction. A bounded self-check can help when mistakes are objectively detectable, while a limited automated loop can make sense when the task repeats, verification is reliable and the budget can absorb failed attempts.
Fully autonomous workflows should be reserved for situations where the value of the completed work justifies the potentially unpredictable inference cost. There is no prize for maximizing the number of agents involved in your life or business. A sophisticated AI user is not somebody who automates everything. It is somebody who knows which parts are worth automating.
AI literacy includes knowing when not to use more AI
For several years, people were told to learn prompt engineering. Now they are being told that prompts are obsolete and everyone should orchestrate autonomous agents. Soon there will be another abstraction layered on top of agents, accompanied by another wave of people insisting that anyone who does not adopt it immediately will be left behind.
Sophistication is not measured by how complicated your workflow becomes. Sometimes asking an AI to complete a task, check three clearly defined conditions and return the result is genuinely better engineering than an autonomous eight-agent system working through the night. It can be cheaper, clearer and easier to control.
The agentic future is real, but so are quotas, token costs, premium requests, context growth, unreliable verification and diminishing returns. Those realities matter disproportionately to the millions of people who are not operating an AI startup, cannot charge inference to an employer and are not prepared to spend hundreds or thousands of dollars per month on compute.
They also matter to small and medium-sized companies being pressured to adopt AI before they have developed the ability to measure its real operating cost. We should be careful when turning techniques developed for wealthy, high-value engineering environments into universal productivity advice.
The question should not be, “How much of this can I make autonomous?” It should be, “What is the cheapest combination of my attention and AI inference that produces a result I am happy with?”
For most people today, the answer is neither completely manual prompting nor completely autonomous agents. It is somewhere in the middle. That boring middle, built from good instructions, selective verification, human judgment and bounded automation, may be the smartest and most sustainable way to use AI.
Discussion
No comments yet. Be the first to share your thoughts!