An AI coding agent spends most of its budget on discovery: opening files, grepping for names, walking imports, then doing much of it again to be sure. Across 9,459 real agent traces, 47.5% of all agent work was redundant or wasted. The writing is cheap. The searching is what you pay for.
And handing the agent a bigger map doesn't fix it — often it makes things worse. We tested this directly: in our tests, handing the agent more powerful context tooling repeatedly came in above a plain vanilla agent on cost. Give an agent a powerful capability and it uses it, exhaustively — without guardrails it goes on a data odyssey, pulling far more context than the mission needs. More retrieval, more tokens, more turns: the fix becomes the bill. The problem was never too little context — it's too much, ungoverned.
Every session opens blank. The agent has no dependency picture, no sense of which files matter, no recollection of last week's identical hunt. It compensates the only way it can: read widely, check often. Rational behaviour. Expensive behaviour.
We measured it rather than asserting it. Across an independent corpus of 9,459 real agent traces, 304,929 steps, nearly half of everything the agent did was work it did not need to do.
Every figure below is measured: from the independent trace corpus, or from sealed paired runs published in full on /research. Where a result costs us something, it is on the page anyway.
Watch a long session and you will recognise the shape. The agent reads a file, moves on, loses confidence, and reads it again. It verifies a change, then verifies the verification. Roughly 60% of the measured waste is exactly this: rediscovering and re-checking things the agent already knew.
Confidence is the expensive part. The model cannot cheaply trust its own earlier reads, so it pays for certainty over and over.
~60% of the redundant work in the 9,459-trace corpus is rediscovery and verification: re-reading known files and re-checking known state, not exploring new ground.
For a given task there is a computable floor: the smallest set of tool calls a competent execution actually needs. Unassisted agents do not get near it. On sealed paired tasks the unassisted agent took 14 tool calls where the floor was 4. On a real spreadsheet task, 15 calls against a floor of 3.
The gap is not carelessness. It is blindness: every call above the floor is the price of not knowing where things are.
Talon's tuned serves reach the computed task floor — 4 tool calls where an unassisted agent takes 14. We count calls and turns, nothing hypothetical.
Is the waste uniform? No. It runs deepest on large, private, heavily-indirected codebases, where a text search answers nothing because the real context lives in the code's structure, not its text. It shrinks toward zero on a small repo a single grep can cover. Sometimes it goes below zero.
On a small TypeScript repo of about 1K files, Talon cost 1.236×: more than the unassisted agent. Some tasks show NO_HEADROOM, nothing to save at all. We measure both and we publish both.
Python 0.41–0.63× at resolve parity (44K–1.3M LOC) · Java 0.605×, 11/12 wins · TypeScript 0.761×, 10/11 wins · small TS ~1K files 1.236×, a published loss · 35–50% saving on >400K-LOC codebases · 0.84× on private, post-cutoff code the model has never seen (n=23).
Talon predicts the context each step needs, serves it before the agent goes looking, and steers the agent past redundant search — the structural context that flat search and embeddings miss. The outcome: the agent stops searching and starts at the work. 45% measured on sealed paired tasks.
Quality holds while the cost falls. Solve rate sits at roughly 60%, parity with an unassisted agent, with 2× fewer broken tests on SWE-bench-100. The 37–50% token cut means less spend on API, or more work before a Max cap — same model, same result, fewer tokens; on a capped plan, 1.6–2× more work per window. And it runs inside the agent you already use, on your keys or ours.
And because the saving tracks how hard your code is to search, you can screen your own repo first. talon estimate reads your repository in about 30 seconds and returns a savings band before you spend anything — a screen, not a promise. Know roughly what you would save before you pay a cent.
47.5% redundant or wasted · share of steps classified redundant or wasted across an independent corpus of 9,459 real agent traces (304,929 steps); the corpus is not our benchmark harness. Of that waste, ~60% is rediscovery + verification. 4 vs 14 tool calls · the computed per-task floor against unassisted execution on sealed paired tasks (3 vs 15 on a real spreadsheet task); reported in calls and turns.
Sealed cost cells · paired A/B runs at resolve parity; the full per-cell table, method and the published 1.236× loss are summarised on /research. talon estimate · a fast repository scan that returns a savings band; we state it as a screen, not a precise predictor.
Nothing on this page is estimated silently. Unmeasured is absent, and results that hurt us stay published.
Sealed paired runs on real codebases: the full per-cell table, the published loss, the tasks with nothing to save. See the proof, then run it on your own repo. No pressure either way; the numbers do the arguing.