Written October 2026. Reflections on agent overruns and self-reported spend, October 17 to 26, 2026.

The hand-back said the task had used “about 50k” tokens. The brief had allowed 120k. The log footer, which the tool writes when the run ends, said 232,658.

That was October 19, and it was the one that changed my mind. I had been treating a budget as an instruction: write the limit into the prompt, tell the agent to stop at a point short of it, and trust the stop. In that case the agent was off by a factor of 4.6 in the direction that made the work look cheap.

The setting

The setting is the Grid, a personal artificial-life simulation I run, where small programs evolve in a world with chemistry, seasons and predators, and a committee of AI agents (Claude, Codex and Gemini) designs, runs and checks the experiments. Codex does most of the engine coding. Claude orchestrates and checks.

The budgets here are token counts per task. They are ours, sized to our work, and I am not offering them as numbers to copy.

What the records show

The first signs came on October 17 and 18, when a Codex coding task had hit its usage limit before it finished. Builds that were scoped at about 100k tokens had been running to 234k and 261k. One task reached 184k and stopped on its five-hour limit with the verification gates (the automated correctness checks) not yet run. A different agent finished the gates so the work was not left idle. Our log recorded the pattern: coding work had roughly tripled, and the tasks had not shrunk to match.

On October 18 a Codex build was 75% through its context window (the model’s working memory for the task) fourteen minutes in. It had printed the same block of parameters 120 times through repeated print commands. A read-only review ballot (a review in which an agent ranks options and votes) scoped at 60k used 149k, and the five-hour usage window moved from 6% to 34%.

On October 19 the pattern was consistent across tasks. Codex tasks ran at 154k against 110k, then 232,658 against 120k. Our lessons log counts five overruns in a row on prompts that carried a hard stop. The same day, the log records Claude subagents misjudging their own spend: one reported 62k and was measured at 98k, another reported 75k and was measured at 119k. Those reports ran about 1.6 times low.

Then on October 26 a journal-writing subagent claimed it was “within the 55k-token budget” when the evaluation put it near 123k. The evaluation’s note on that claim stayed with me: it was a false spend claim the agent cannot see tokens to make.

The 232,658 and the 98k and 119k figures are measured: they come from the log footer or the usage notification, outside the agent. The “about 50k”, “62k”, “75k” and “55k” figures are self-reports. I am quoting both because the gap between them is the finding. I did not take any of these measurements fresh for this essay. They are the figures our logs recorded at the time.

Why prompt limits failed

My first reading was that the agents were careless. I wrote stricter stops into the prompts, including one at about 100k that said to finish the current step, write up what remained, and stop. It was ignored on five tasks in a row.

That reading was wrong, and I accepted it for too long. The agent could not see its own token count. Asking it to stop at a number it cannot observe is asking it to guess, and in practice, agents near the end of a task finished it rather than stopping at a number they could not see. The accounting boundary I had asked for did not exist inside the worker.

So the fix moved outside. Three changes, made between October 18 and October 26:

  • Spend is read from the log footer or the usage notification, never from the summary. Agents no longer self-report token counts at all. A hand-back ends with a status section (done, not done, not verified) in place of a number.
  • Stops became things the agent can observe. Tool calls after the first scored table replaced token thresholds, and a later rule added a call-count proxy and an output-size proxy. We counted all tools, because one evaluation found a spend line that counted only some of its tool calls.
  • The task got smaller. Builds over about 300 lines were split into two tasks of about 150 lines. Build and light checks went in the first. The heavy determinism gates went to a separate agent that reruns them independently. We also capped printed output at 40 lines per command, which addressed the cause of the 120-print loop.

The last change did the most. A build that also validates itself has no natural place to stop. A task that ends at the code and its unit tests does. An overrun in a small task costs a small task, and a fresh agent can start from the hand-back note instead of resuming a long, crowded context.

I should be careful about what this shows. It is one project, one worker, about two weeks. The overruns shrank after the split, but I have not measured dollars saved or productivity gained, and I will not claim either. What I can say is that the sizes of the overruns we could see in the logs stopped being the main source of surprise.

For leaders running agent work

Three questions, offered as questions because they come from this one setting.

Who measures the spend? If the only number comes from the worker, it is a claim. A figure from outside the worker is a measurement, and the two can differ by a factor of several without anyone lying.

What is a task, in a unit someone can review? In our runs, a budget attached to an open-ended goal was overrun almost every time. A budget attached to a reviewable deliverable, with its verification assigned elsewhere, at least fails visibly.

What does the stop depend on? A stop that relies on the agent perceiving something it cannot perceive is a hope. One that relies on a count the harness can see is a rule.

A brief pattern

This is the shape our briefs ended up with. It is derived from this work and I do not claim it is the best template.

  • Goal and exclusions: one or two sentences on the outcome, and what is out of scope.
  • Inputs: the specific files to read first, by name.
  • Limits: the task’s size, “task N of M”, and an advisory budget sized at about 1.5 times the estimated work.
  • Output economy: targeted searches and summary diffs only, with a cap on any printed section, and no full dumps of diffs, logs or fixtures.
  • Done means: the checks this task runs, and the checks left to a separate verifier.
  • Hand-back: what changed, what was verified and how, what was not verified, any processes left running, and a status section. No token counts.

Spend is recorded against the brief afterward, from the measured source, so the next brief can be sized from evidence.

This week

Pick one agent task you ran recently and compare what the worker said it cost with what your tooling recorded. Then ask whether the task was a deliverable someone could review on its own. If you have run into the same gap, I would like to compare notes: connect on LinkedIn.