The attention budget and what dilutes it

The budget

How much does a token that contributes nothing cost the answer a model gives? The intuitive price is zero: the model will read past the useless line the way a person skims one, and whatever matters still receives its full consideration. The intuition is wrong, and the reason sits in arithmetic the model cannot opt out of. Each time a model produces the next token, the next word-sized piece, of its answer, it distributes attention across everything in its window, and that attention is a normalized whole: the shares sum to a fixed total, and no token's share is ever exactly zero.

A context window is therefore not shelf space, where an unused item costs nothing beyond the room it occupies; it is a budget. We call it the attention budget: the fixed whole of attention a model spreads over its window, from which every token present, useful or not, draws a share. Understood that way, the inside of a window is a fight for attention, and this note is about that fight: why useless material makes the answer worse, how we watched it happen in our own systems, and what we now build because of it.

The mechanism

The mechanism deserves a careful plain statement, because it is simple and its consequences are not. A model answers by attending: for every token it writes, it looks back across every token it holds and assigns each one a weight, how much to draw on that token for the word being produced now. Those weights are not open-ended scores that grow as the window grows. They are shares of one whole, normalized to always sum to the same total; put one more token in, and the whole is not enlarged, it is divided one more way.

That is why an irrelevant token is never free. It pays nothing into the answer and still draws its share, because no share can reach zero. One stray token costs nothing anyone could notice, but a window filled with them thins what remains for the material that actually decides the answer: tool output that has served its purpose, logs pasted whole, instructions for situations that are not this one. We call the thinning attention dilution: the share of the budget left for the tokens that matter, shrinking as the window fills with tokens that do not. Dilution is gradual and structural: that it happens at all follows from the fixed total itself; how much it takes, the arithmetic does not say; that is what we kept meeting in practice. No better phrasing removes it: however an instruction is worded, it sits inside the same window, competing for the same whole.

What we observed

If the arithmetic is everywhere, the effect should be everywhere, and in our systems it is. A long session that builds a page, screenshots it, critiques the result, and goes again accumulates its own exhaust, the screenshots and verdicts and residue of every earlier pass, and by the late iterations the judgment has visibly dulled in the same session that had been sharp earlier. The task had not changed in kind; the window had grown.

The same shape appears when raw material is carried back whole. A research sweep that returns everything it touched, logs and listings and page after page of source, degrades the thread that receives it, not because anything in the haul is wrong but because from that turn onward every answer is composed over it. And the shape appears a third time, in evaluation, where one session grades another's output: a judgment made inside a loaded session inherits the session's dilution, because the judge is spreading the same budget over the same exhaust as the worker it is judging.

None of these observations arrived as numbers, and we will not dress them as measurements. They arrived the way structural causes do in deployment: the same degradation surfacing in visual work, in research, in evaluation, across activities that share nothing except the model underneath, until one common cause was easier to believe than that many coincidences.

From geometry to dilution

An earlier note in this series, on why "memory" is the wrong word for what agents have, already stated the seed of this one: stuffing more into the window does not add memory, it dilutes attention. That sentence has governed our work since.

This spring it collected its evidence, and we wrote it up in a post from the lab: a standing instruction that tested perfectly in isolation was skipped every single time across three long working sessions. The instruction was clear, correct, and present in the window through every failure; presence was not the operative variable. Two layers explained the miss. Across today's models, attention in a long window runs uneven by position, thinnest toward the middle, so where the instruction sat shaped how much attention tended to reach it. And models arrive trained to weight some parts of the window over others: recent turns and tool definitions rank high, standing instructions low, so what the instruction was also worked against it. That post named the two together attention geometry, where attention concentrates and what the model was trained to weight, as one design variable, and it drew the conclusions we still operate by: place critical rules where attention concentrates, convert recurring failures into forced structure rather than stronger wording, architecture over willpower.

Geometry, however, left one quantity implicit. It describes where attention lands and says nothing about how much is left to land on what matters, because that is set earlier, by everything the window was allowed to contain. A perfectly positioned rule inside a window carrying many times the tokens the task needs is well placed within a diluted whole; the shares are already thin before geometry decides where the largest ones fall. That is the layer this note adds, and the order matters: dilution first, geometry on top.

The structural response

What we build has reorganized around spending the budget deliberately, and the practices are plain once the arithmetic is accepted. The iteration sessions were restructured so their exhaust never enters the working thread: checks run, verdicts return, and the residue stays outside the window that carries the work forward.

Research runs in separate instances that come back with summaries and never with raw logs, so the thread that composes answers works from distilled findings rather than from everything a sweep touched.

Evaluation moved to clean context: outputs are judged in a fresh window holding only the material under evaluation, because a verdict is an answer too, and deserves an undiluted budget as much as the work it judges.

Beneath all three sits the discipline our last note named the scoped turn, each turn carrying only what the work in front of it needs, which reads in this light as budget policy: the standing decision, renewed every turn, about what may make a claim.

None of the practices is an instruction to the model; they are structure around it. A model can be told to care less about what its window contains, and the weights may listen; no instruction makes a share zero, because the arithmetic is not listening. The budget can only be reliably protected before the window is composed, and that is where each of these practices operates.

The fight for attention

A context window is usually described as capacity, and capacity sounds like an invitation to fill it. The budget frame inverts the instinct. The window is the surface over which a fixed whole of attention will be spread, every token admitted is a decision about where that whole goes, and the fight for attention is not won at generation time alone, by the model straining toward what matters; it is decided at composition time, by whoever chooses what enters, and mostly by what they leave out.

This note adds the attention budget and attention dilution to the pair we already build with, attention geometry and the scoped turn; the four make one sentence: decide what may claim the budget, then place what matters where attention concentrates. A model does not answer with everything it was given; it answers with the attention that survives what it was given.