Why does token cost in a naive agent loop grow quadratically with step count?

An agent solves a task by looping: it reasons, calls a tool, reads the result, and repeats. The catch is that an LLM has no memory between calls. The only way it remembers what already happened is that you resend the entire transcript on every single turn. So on turn one you send a small prompt. On turn ten you send all nine earlier steps plus the tenth. The input you pay for on each turn grows with the turn number. Now add up the cost across the whole run. Turn one costs one unit, turn two costs two, turn ten costs ten. The total is `1 + 2 + ... + N`, the triangular sum, which grows like N², not like N. That is why the correct answer is the one about re-sending accumulated **context**. It is not that tokens get pricier or the model gets bigger. The price per token is flat. The token count is what explodes, because every turn drags the whole history along with it. The practical lesson is that doubling the number of steps roughly quadruples the bill, so long agent runs need active context trimming.

In a naive agent loop the cost grows quadratically because the LLM is stateless. Memory is faked by resending the full transcript every turn. So the input at turn k is roughly proportional to k. Let each step add about C tokens of new content. Then turn k sends about `k·C` input tokens. Summing the input across all N turns gives the headline relation: $$\text{Tokens}(N) = C \sum_{k=1}^{N} k = C \cdot \frac{N(N+1)}{2} = O(N^2)$$ This is the triangular number. It scales with the square of the step count, not linearly. Doubling steps roughly quadruples spend. The distractors all blame the wrong mechanism. Per-token price is flat, so pricing is not the cause. Model parameter count does not change with input length. Tool calls are not billed at a premium. The single cause is context accumulation. Every turn re-pays for the entire history. The fix is to stop the input from scaling with k. Summarise old turns, store full tool outputs in a side store and inject only ids, or use a sliding window. Each keeps per-turn input near constant, which pulls total cost back toward linear.