The Agentic Loop

What Happens to the Regeneration Tax When Nobody Is Holding the Camera

1. The Photographer Leaves the Room

Our last paper ended with a promise. In the section on code, we wrote that agentic AI coding — tools that generate, test, discard, and regenerate entire changes autonomously — deserved a paper of its own, and that we intended to write it. This is that paper.

To get at what changed, I want to go back to the two photographers from last time. With film, I shot less and cared more, because every frame cost money. Digital broke that discipline — nothing riding on each frame, so I shotgun my shots, trusting volume to get me to a good one. That was the subject of The Regeneration Tax: when cost disappears from the view of the person making the attempt, the attempts multiply, and nobody counts them.

But there was a limit to that story, and I glossed over it. In every case I described, a human was still in the loop. A photographer clicks the shutter. A prompt-writer clicks "regenerate." A developer reads the suggestion and decides whether to accept it. The waste was real, but it was chosen — by someone who could, in principle, have stopped. The regeneration tax had a ceiling, and the ceiling was human patience. People stop re-rolling when they're bored, frustrated, or satisfied. Six or seven attempts, then they give up or settle.

Agentic tools remove that ceiling entirely. They don't just make re-rolling cheap. They take the human out of the loop altogether.

Picture the scene. You type a sentence into an agent: "Fix the failing test." Then you go to read email. Behind you, the agent writes code, runs it, sees it fail, reads the error, rewrites it, runs it again — ten times, twenty times, fifty times — without asking anyone anything. It stops only when the tests pass or the token budget runs out. No human chose any of those iterations. No human even saw most of them. The shotgun has become the software.

This is the regeneration tax with no one holding the camera. And it is, I think, the largest avoidable multiplier in the whole stack — not because the per-iteration cost is higher than video, but because the number of iterations is no longer bounded by anything human.

One thing to state plainly before we begin, as in every paper in this series: this paper proposes no solutions. Decisions about agent design, pricing, and infrastructure belong to people with expertise and data we do not have. What we do here is describe, in plain language, a problem that is real, large, measurable, and almost entirely missing from public conversation — then lay out the questions the people who do have the data should be asked, by the press, by policymakers, and by each other. Our single request of the industry is disclosure. The rest is a conversation we aim to start, not settle.

2. A Few Terms, in Plain Language

This paper builds directly on the terms introduced in The Regeneration Tax. If you've read it, much of this will be familiar — skim down to the new ones. For everyone else, here is the short list everything below relies on.

3. From Autocomplete to Autonomy: Three Generations of Coding AI

To understand why agentic tools are different in kind rather than degree, it helps to see where they came from. Coding AI has gone through three generations, and each one moved the human further from the loop.

Generation one: autocomplete. The tool suggests a line or a function as you type; you accept or reject it. This is GitHub Copilot's territory, and it is squarely within the scope of our previous paper. The regeneration tax here is roughly 3–4x, because for every suggestion a developer accepts, two to four were generated and discarded. But notice the shape of it: a human makes every decision. The suggestion arrives unsolicited, but the acceptance is human. The waste is bounded by how many suggestions a person is willing to glance at.

Generation two: the chat assistant. You paste code into a chatbot, get back a diff, and apply it yourself. Here the human is still choosing — you decide what to ask, whether the answer is right, and whether to ask again. Regeneration remains human-driven. This is the world our previous paper described, and the one where the interface teaches the behavior.

Generation three: the agent. You state a goal, and the tool does the rest. It plans, edits files, runs your tests, reads the errors, and iterates until the tests pass — or gives up. No per-step approval. This is Claude Code, Cursor's agent mode, Devin, and their rapidly multiplying peers. And it is a genuinely different animal, because the regeneration is no longer chosen by anyone.

The difference is not subtle. In generation one and two, the regeneration ratio was bounded by human attention. A person re-rolls maybe six or seven times before getting bored, frustrated, or satisfied — the plateau we documented in our previous paper. An agent has no such limit. It will iterate dozens or hundreds of times without fatigue, and the only stop conditions are a passing test or an exhausted token budget. Neither of those is a human deciding the work is good enough.

So the question this paper asks is simple: if the regeneration tax was already 3–25x when humans did the re-rolling, what is it when nobody does?

4. What the Loop Actually Costs

Let's put numbers on it, as honestly as we can. The honest part matters here, because the central finding of this section is that the key number — iterations per completed task — is not published by anyone. So we build the math from what is known, and label every extrapolation as ours.

Per-iteration cost. One agent iteration is not one inference. It is several: the agent plans what to do, generates code, calls a tool to run it, reads the result, reflects on whether it worked, and decides what to do next. Each of those steps is a full-price inference, and the reflection steps — the agent thinking about its own work — are pure overhead that produces no output at all. A single iteration plausibly costs several times a single generation call, before we even count how many iterations there are.

Iteration counts. This is where the data thins to nothing. Vendor benchmarks like SWE-bench report whether an agent solved a task, not how many iterations it took. Public anecdote and developer reports suggest agents routinely run five to fifty internal iterations per task — and sometimes far more on hard problems. We treat these as directional, not measured. The point is not the exact number; it is that the number is large and unbounded by human patience.

The compounding effect. Our previous paper documented code churn — code rewritten or deleted within two weeks of being committed — climbing from a 3.3% baseline to 5.7% in 2024, in the AI-assistant era. Agentic code accelerates that. It is generated faster, reviewed less carefully, and rewritten more often. The slow-motion regeneration of the autocomplete era becomes fast-motion: code is produced, kept briefly, then replaced — often by another agent, running another loop. The waste compounds across generations of the same codebase.

Set it side by side, the way we did last time.

Table 1: Who does the re-rolling, and what it costs. Autocomplete and chat figures carry over from Paper 4 (Appendix A). The agentic row is the authors' scenario framing, not a measurement — see Appendix B. The tiers follow the series convention: [V] vendor-published, [R] on-record reporting, [A] academic, [M] authors' modeling.

The asymmetry that matters most is not in the table. It is this: in the autocomplete and chat cases, the waste was concentrated in content that gets thrown away — a rejected suggestion, a discarded image, a meme video nobody keeps. In the agentic case, the waste is concentrated in production infrastructure. The code an agent writes and rewrites is the code that runs banks, hospitals, airlines, and grids. The stakes are not a funny video. They are the systems the world depends on.

5. Why the Multiplier Grows Unbounded

Our previous paper identified three properties that made the regeneration tax consequential: a regeneration is a full-price inference, the tax compounds, and it is invisible in every disclosure. Agentic AI keeps all three and adds a fourth that is, I think, the sharpest of them all: the multiplier has no natural ceiling.

In every case we documented before, something human set the upper bound. The ad director stops when the clip is good enough to air. The image-maker stops re-rolling around the sixth or seventh attempt. Even the most careless user eventually gets bored, runs out of credits, or settles for good enough. An agent has none of these. Its stop condition is algorithmic, not psychological — and that single difference is what turns a large multiplier into an unbounded one.

An agent has none of these. Its stop condition is algorithmic, not psychological. It stops when the tests pass, or when the token budget is exhausted — and neither of those is "this is good enough." A test passing is not the same as the task being right; it is the same as the task satisfying whatever assertions the developer happened to write. And a token budget is a business decision, not a quality judgment. An agent that runs out of budget mid-task simply stops, leaving the work half-done, and the next agent picks it up and starts its own loop.

Worse, the failure modes compound in a way human re-rolling never did. When a human re-rolls, each attempt is independent — you ask for a different image, you get a different image. When an agent iterates, each attempt builds on the last. A wrong assumption early in the loop propagates through every subsequent iteration, so the agent spends many iterations fixing problems its own earlier iterations created. This is self-inflicted regeneration: the machine generating work specifically to clean up after its own mistakes. No human ever did that.

And there is a deeper point hiding here. Vendors sell agents on exactly this property. "It keeps working until it's right" is the marketing pitch — which is, translated literally, a description of unbounded regeneration. The loop is not a bug in the product. The loop is the product.

6. The Evidence Base — and Its Gaps

Let's be precise about what is known and what isn't. The evidence base for agentic AI's footprint is thinner than for any modality we've covered, and the gap is itself the finding.

What exists publicly. There is a growing body of benchmark research — SWE-bench and its successors — that measures whether an agent solves a coding task. But these measure success, not effort. They tell you that an agent fixed the bug; they do not tell you how many iterations it took, how many inferences it burned, or how much energy it consumed along the way. A benchmark that reports only completion is measuring the wrong thing for our purposes.

There are also vendor claims about capability — "our agent solved X tasks," "our agent outperforms Y on Z." These are marketing statements about outcomes. None of them disclose the cost of achieving those outcomes. It is the same pattern we have documented four papers running: the number exists, is measured, and is withheld.

What does not exist. No vendor has published an iterations-per-completed-task figure. Not one. This is the agentic equivalent of the regeneration ratio — the single coefficient that would let anyone estimate the footprint of agentic AI — and it is nowhere in public. We searched. It is not there.

We also found no published measurement of how often an agent terminates because it succeeded versus because it ran out of budget. This matters enormously: an agent that completes 80% of tasks in 5 iterations and 20% in 200 iterations has a very different footprint than one that spreads its effort evenly. The distribution is unknown.

And there is no published accounting of how much agentic compute is spent correcting the agent's own earlier mistakes — the self-inflicted regeneration we described in Section 5. Given how central this is to how agents actually behave, its absence from the literature is striking.

Because the real numbers are secrets, this section is partly modeled. Where we lack a measurement, we label the figure as ours, in the [M] tier, exactly as we did in our previous paper. We would be delighted to see any vendor embarrass us with the real number.

7. The Tool Is Complicit, Again

Our previous paper argued that the interface teaches waste — that the regenerate button, placed one click from every output, taught users to shotgun. The tool was complicit in the behavior it enabled. Agentic AI takes that complicity to its logical end.

In the image and video cases, the interface at least showed the user the waste. You saw the grid of four near-duplicates. You watched the discarded frames pile up. The waste was visible, even if the cost wasn't. The user was present for the excess, even if they couldn't see the meter.

Agents remove even that. The failed iterations happen invisibly, behind the scenes, while you read email. You never see the discarded attempts at all. You see only the final result — or, worse, the partial result left behind when the budget ran out. This is the first modality where the waste is not merely unmeasured but unseen by the person who asked for it. There is no contact sheet to show, because nobody is keeping the frames.

The incentives point the same direction as always. The design goal of an agent is minimal human intervention — fewer approvals, less babysitting, more autonomy. Every reduction in human oversight is an increase in autonomous regeneration, and vendors market that reduction as a feature. Engagement metrics reward longer-running loops. Flat-rate subscriptions make marginal cost zero. And nobody in the loop is rewarded for efficiency — you are rewarded for the task being done, not for the agent doing it cheaply.

This is not an accusation of intended harm. It is simpler, and it is the same observation we made last time: nobody in the loop has a reason to care. The user can't see the cost, the product team is rewarded for the behavior, and the utility bill is somebody else's line item. Systems shaped like that do not self-correct. They get pressed from outside — which brings us to the questions.

8. The Questions That Deserve Answers

Our role is not to design fixes. We claim expertise adjacent to this topic — decades in large-scale software infrastructure, and four papers on AI's resource footprint — not in agent design, energy science, or data center operations. The people with the data and the real experts need to have this conversation with each other, in public. What we can supply is the questions — sorted by who should be answering, and who should be asking.

For the AI vendors

To be asked by reporters, by analysts on earnings calls, and by policymakers in hearings:

• What is your median iterations-per-completed-task across your agent products? You measure this today. Why has it never appeared in a sustainability report?
• What fraction of agent loops terminate because the task succeeded, versus because the token budget ran out? The difference determines whether your agents are efficient or merely persistent.
• Do you log and report autonomous regeneration separately from user-initiated regeneration? If not, why not — given that they have very different footprints and very different ethical implications?
• How much of your agentic compute is spent correcting the agent's own earlier mistakes? This is the self-inflicted regeneration of Section 5, and it is presumably tracked.

For the research community

• Who will measure, at scale, the actual iteration distribution of deployed agents — the missing coefficient for the entire agentic footprint? Benchmarks currently report completion, not effort.
• Does the stop-condition design causally change total compute? Does an agent told "keep going until tests pass" burn materially more than one told "stop after N iterations"? By how much?
• How much of agentic compute is spent correcting the agent's own earlier mistakes — and does better planning reduce it, or merely shift it?

For the press and for policymakers

• The next time a company announces "our agent solved X tasks," the follow-up is one sentence: how many iterations did that take, and how much energy? No reporter has yet asked it on the record.
• If per-query energy figures are starting to appear in policy debates over data center buildout, should per-task figures for agentic AI be required to include iteration counts? A number that omits the loop is not evidence; it is advertising.
• Should autonomous regeneration — waste no human ever requested — be disclosed differently than user-driven waste? The former is designed into the tool; the latter is a user choice. They are not morally equivalent, and treating them as such hides the one that is fixable.

None of these questions is hostile, and every one can be answered by people who already have the data. Our request is that they be asked — repeatedly, in public, by people whose questions cannot be ignored — until the answering starts.

9. My Actual Take

Since these papers have made a habit of ending with what I actually think, here it is.

The photography analogy extends further than I took it last time. Autocomplete was burst mode — you fire off a lot of frames and keep the good ones. The chat assistant was a camera with a big buffer. The agent is the camera that shoots for you. It doesn't wait for you to press the shutter. It just keeps taking pictures until it thinks it has one, and then it shows you only the one it likes. You never see the other ninety-nine.

Here is the uncomfortable truth. Last time I argued the regeneration tax was steepest exactly where the output matters least — the disposable end of the content spectrum. That critique had a soft spot, and I want to own it: the regeneration tax was arguably defensible as "users choose to waste." A person who rolls a prompt twenty times is spending their own credits on their own amusement. Wasteful, yes. But chosen.

Agentic waste is not chosen by anybody. It is designed into the tool. You didn't ask the agent to try forty times; you asked it to fix a test. The forty attempts are the product's architecture, not the user's behavior. Here, for the first time in this series, the blame cannot be laid at the feet of a careless human.

And that is precisely why it is the most fixable form of waste in the whole stack. Changing millions of users' behavior is nearly impossible — you'd have to redesign the psychology of an entire population. Changing a stop condition or a token budget is a single engineering decision, made by one team, shipped in one release. The waste is not just the vendor's fault. It is the vendor's to fix, and only the vendor's.

This criticism does not come from the anti-AI corner. I think AI is one of the great boons to humanity in my lifetime — I co-write these papers with one — and I want to see it used for the benefit of all. That is exactly why the waste matters. Every kilowatt-hour spent on the fiftieth autonomous iteration of a routine refactor burns social license — grid headroom, the patience of communities hosting data centers, goodwill in legislatures — that AI's genuinely transformative uses are going to need. And unlike the meme-video waste, this waste sits in production infrastructure, where it is hardest to dismiss and easiest to resent. The real threat to AI's future isn't the people pointing at the waste — it's the waste itself. Left invisible long enough, it will bring a backlash that takes down the good uses along with the bad. Transparency now is how this technology keeps its welcome.

I've spent forty-plus years building large-scale software systems, which qualifies me to recognize this problem and describe it honestly — not to design the fix. That belongs to the people inside these companies who already stare at the real numbers, the researchers who measure these systems for a living, and the policymakers whose job is to weigh public costs. My job, in these papers, is to make the problem legible enough that those people can no longer talk past it. What I want isn't my solution adopted. It's the conversation held, in public, with the data on the table.

10. Conclusion: The Loop Without a Lens

Film photography had an instrument of honesty called the contact sheet: every frame on the roll, keepers and mistakes alike, printed small on a single page. It existed for a practical reason — you had to see everything to choose anything — but it had a moral side effect. It confronted you with your own waste. Twelve nearly identical frames, eleven of them money wasted, staring back at you at once. You couldn't not know.

Our previous paper ended by asking the industry to show us the contact sheet. The agentic era answers that request in a way I did not anticipate. The contact sheet isn't just hidden anymore. It has been automated. The frames are generated, evaluated, and discarded by software, and no human ever looks at them. The waste is not concealed from view. It has been removed from view entirely — there is no sheet to show, because nobody is keeping the frames.

This paper had one purpose: to establish that the agentic loop exists, that it multiplies the regeneration tax beyond any human ceiling, that it is known, and that it is withheld — and to put the right questions in the hands of the people positioned to ask them. Somewhere above the 3–25x range we documented last time, everything currently believed about the per-output cost of generative AI is an undercount. Narrowing that range requires nothing to be invented. It requires only that someone who already has the number decide, or be pressed, to share it.

Tell us how many times the agent tried before it got it right. You counted. We can see you counted.