The loop you can actually afford

The post crossed 8.2M views. Stop prompting, start designing loops. A screenshot of roughly $1.3M of tokens in 30 days, about 603 billion of them, across roughly 100 agents running flat out. The takeaway everyone retweeted: the future is autonomous loops, and you are behind if you are still typing prompts.

Here is the context that did not fit in the screenshot.

The person posting that number works at the lab that makes the tokens. For them, the cost of a token is close to zero. That changes the math completely. When the meter does not point at your own bank account, running overnight loops at full tilt is an easy call. It is a real and useful way to work. It just rests on an economics most of us do not share.

Which is the honest takeaway, and a more useful one than "loop or be left behind":

Running big loops well is a skill worth learning. Affording them is a separate problem, and for most of us it is the binding one. The answer is not to outspend the people with cheaper tokens. It is to see your own bill clearly enough to cut the waste out of it.

Why the naive loop is so expensive

It is not that the model is smart and smart is pricey. It is the shape of the loop.

An autonomous, Ralph-style loop re-sends the full context every single turn. The model reads the whole working set again, writes a little, and goes around again. Input tokens, not output tokens, drive the cost, and a re-reading loop is almost all input. Twenty turns is not twenty small requests. It is twenty increasingly large ones.

And an uncapped loop has no spend ceiling by construction. The only thing that stops it is success, or a human noticing the number. That is the easiest loop in the world to set up, which is exactly why the expensive version is the one that spreads.

The five plays that cost a fraction

You do not have to choose between running loops and affording them. The same discipline the influencers sell has a cheap version. Five plays:

1. Spend the thinking before the tokens. Write the spec, the checklist, the acceptance gate before you start the loop. A loop pointed at a vague goal re-discovers the goal every turn, on the meter. The cheapest token is the one you never send because the loop already knew where it was going.

2. Plan cheap, execute expensive. You do not need the top tier to plan, decompose, or triage. You need it for the one hard step. Route the high-volume reasoning to a mid or small model and reserve the expensive tier for the work that actually requires it. Most loops burn their top-tier budget on steps a cheaper model would have done identically.

3. Turn on caching. If your loop re-sends a stable prefix every turn, the system prompt, the spec, the repo context, prompt caching makes that prefix nearly free after the first read. For a context-re-sending loop this is the single highest-leverage switch you can flip, because the re-sent context is precisely what caching discounts.

4. Engineer the context: delegate reads, centralize writes. This is the Cognition / Devin pattern. Do not let one giant agent carry one giant context that grows every turn. Delegate the reading to sub-agents that return only their conclusions, and centralize the writing in one agent with a lean context. The tell that you got this wrong: a bloated context, a tool mix dominated by reads, a low output-to-input ratio. The loop is mostly re-reading, barely writing, and paying for every re-read.

5. Be the loop yourself, and cap the run. The most autonomous loop is not always the right one. Sometimes you are the controller. And when you do run it unattended, cap it. The Vercel AI SDK ships maxSteps, commonly set to 20, precisely so a loop has a ceiling. A capped loop has a knowable worst-case bill. An uncapped one does not.

RepoOps already does the math for you

Here is the thing that makes this more than advice. RepoOps reads the telemetry your coding agents already produce, and all five of those plays are now automatic findings.

fresh context turn after turn but barely writes, the signature of a loop re-deriving a vague goal on the meter. The fix it hands you: write the spec before the loop, not during it.

and RepoOps will open the PR that downgrades the over-provisioned step for you.

RepoOps flags the prompt-caching and surface-caching wins from your own cache-read numbers.

cause behind the symptoms you could already see (context bloat, read-dominant tool mix, low output ratio), one growing context doing its own reading instead of delegating it.

finishes at turn 8, double-checks at turn 12, and is still going at turn 40, and it estimates the dollars that spinning tail cost.

• Play 1 (spec-first) is the spec-gap finding: it fires when a session pumps in
• Play 2 (plan cheap, execute expensive) shows up as a routing recommendation,
• Play 3 (caching) shows up the moment your loop re-reads an uncached prefix:
• Play 4 (engineer the context) is the undelegated-reads finding: it names the
• Play 5 (cap the run) is the runaway-loop finding: it catches the session that

You point RepoOps at the agent you already run. It does not run your loop. It reads what your loop cost and tells you where it was wasted, in plain findings with a fix attached to each one.

The wedge

The loop-engineering conversation is mostly about the dream of the overnight loop. This is about the meter on it.

Loops are only reckless when you can't see the bill. RepoOps shows you the waste, and the five plays to cut it, before the invoice does.

That is the whole pitch. Not "spend less". Not "stop running loops". See the bill, fix the five things, run the loop you can actually afford.

The Loop Economics scorecard is live: one surface that reads all five plays back to you, each with a count of how many of your sessions tripped it this window and the dollars flowing through the surface it bleeds. Point RepoOps at your agent and watch it name the waste, play by play, with a fix on each one.

It is free, it is local, and it does not phone home. The token screenshots will keep coming, and some of the loops behind them are genuinely worth studying. Learn from them. Then look at your own bill, cut the waste the five plays name, and run the loop you can actually afford.

repoops.ai