9 Ways Agents Waste Tokens (and the Skills That Fix Them)

Why Agents Burn 1000x More Tokens Than Chat — and Why It's Not the Output

If your AI agent feels like it's burning through tokens, the instinct is to blame the output — all that code, those long answers. The data says otherwise. Stanford's Digital Economy Lab found that agentic tasks consume roughly 1000x more tokens than code reasoning or chat tasks, and the bulk of that spend happens before the agent writes anything useful.

The breakdown is striking. In one simulation of agentic coding work, input tokens accounted for 53.9% of total consumption, while the review-and-refinement stage alone ate 59.4%. Actual code generation? Just 8.6%. The agent spends most of its budget figuring out what to do, not doing it.

Part of the problem is mechanical: the "context snowball." Every time an agent makes a tool call, it resends its accumulated history to the model. A task with six tool calls sends most of that history to the model six times, so costs compound with every step rather than resetting.

The deeper problem is that agents re-learn what they already know. As Unblocked's engineering team put it, agents burn tokens because they "spend most of their budget figuring out what they're doing instead of doing it." Their analysis identified four recurring patterns:

• Broad search — querying everything because no authoritative source was provided upfront
• Re-search — relearning facts the agent already had in hand
• Mis-routing — anchoring on a stale or wrong source and building on it
• Runaway loops — retrying on a wrong assumption until the budget runs out

Here's the reframing that matters: this is reconstruction waste, not generation waste. The agent isn't being verbose by nature — it's re-reading, re-learning, and rebuilding context on every turn because it lacks decision-grade context and structured instructions. In a controlled test, simply providing the right context dropped tool calls from 80 to 29 and turns from 50 to 19.

That's good news, because reconstruction is fixable in a way that raw model behavior isn't. Structured workflows, compressed tool output, and clear upfront instructions all attack the input side directly — one benchmark of a structured-skills plugin found 14% fewer tokens, while bounding accumulated input and retry paths cut costs by up to 44% in cited research.

It's also why agent skills have become the fastest-growing fix category. A well-built skill package tells the agent what to read, what to skip, and what to do before it starts — attacking exactly the re-reading and re-learning that dominates the bill. The catch is quality: skills vary wildly, and not all of them actually save tokens. That's the problem SkillzBench is being built to solve, with independent benchmarking of every skill tested with and without it, and the Lift published in plain percentage points.

The waste isn't inherent to agents. It's a context problem — and context problems have solutions.

The 9 Waste Patterns: From Broad Search to Context Pollution

Agentic tasks consume roughly 1000x more tokens than code reasoning or chat tasks, and most of that spend goes to reconstruction rather than the work itself. The waste clusters into nine recognizable patterns, each with a fingerprint you can spot in your own logs.

The first four are runtime failures. Broad search happens when an agent has no authoritative source and queries everything; re-search is relearning facts it already had; mis-routing anchors the agent on a stale or wrong source; runaway loops retry a wrong assumption until the budget wall. All four share one root cause — missing decision-grade context. In a controlled test, supplying that context dropped tool calls from 80 to 29 and turns from 50 to 19.

The next four are output and tool noise. Verbose narration burns tokens on filler, over-engineering adds unnecessary files and abstractions, noisy tool output floods the window with irrelevant lines, and context pollution leaves large raw tool data sitting in the active window. DataCamp's breakdown of these four waste categories pairs each with a named fix, from Caveman's output compression to Context Mode's 315 KB to 5.4 KB reduction of raw tool output.

The ninth pattern is misunderstanding-driven rework. Claude Code's default is to start doing without clarifying questions or a plan, so an ambiguous prompt sends the agent building the wrong thing — and the token cost of a misunderstood task almost always exceeds a few upfront questions.

The mechanism underneath all nine is memory architecture, not model quality. Constraint compliance falls from 73% at turn 5 to 33% by turn 16, and agents cannot self-regulate: models predict their own spend with correlation up to only ~0.39 and consistently underestimate it.

• Broad search — no authoritative source, so the agent queries everything
• Re-search and mis-routing — relearning known facts or anchoring on the wrong one
• Runaway loops — retrying a wrong assumption until budget exhaustion
• Verbose narration and over-engineering — paying for filler and unnecessary structure
• Noisy tool output and context pollution — raw data that never leaves the window

Because skills demonstrably change agent behavior and cost, but published quality varies widely, SkillzBench is building a free directory and MCP connector that benchmark every skill in a sandbox with and without it, publishing the Lift separately from ratings.

Agents Can't Self-Regulate: Why This Is a Budget Problem, Not Just an Engineering One

Your AI agent just quoted you a price for the task it's about to run. Don't believe it. Research from the Stanford Digital Economy Lab shows that models consistently underestimate their own token spend, predicting actual costs with a correlation of only about 0.39 — barely better than a coin flip.

The budget consequences are already visible in the wild. After GitHub Copilot moved to token-based billing in June, some agentic users saw bills jump 10–50x higher. Uber reportedly burned through its 2026 AI coding budget in roughly four months, capping engineers at $1,500 per month. These aren't engineering failures; they're governance failures.

Here's the core problem: the same agent, running the same task, can vary by up to 30x in total tokens consumed. A finance team that budgets based on last month's spend is budgeting on noise. And paradoxically, accuracy tends to peak at intermediate cost — spending more tokens often buys you nothing but a bigger invoice.

Why can't agents police themselves? As one researcher put it, a thrashing agent has no internal signal that it's thrashing. Without external instrumentation, waste stays invisible until the invoice arrives. That means tracking operational metrics, not just dollars:

• Tool calls per task — a controlled test showed providing better context dropped tool calls from 80 to 29
• Repeat-read ratio — how often the agent re-reads context it already processed
• Retry-loop length — how many attempts pile up before the agent gives up or hits a budget wall

Bigger context windows make this harder to govern, not easier. More retrieved material means more plausible-but-wrong sources for the agent to anchor on: by 32K tokens, 11 of 13 models fell below half their short-context baseline on the NoLiMa benchmark. A bigger window doesn't eliminate waste — it gives waste more room to hide.

This is why external measurement matters more than model promises. Skills and structured workflows demonstrably change agent cost behavior, but quality varies wildly and published research has found roughly 26% of skills carry at least one vulnerability. SkillzBench is being built to close that gap: an independent directory where every skill gets security-scanned, pinned to a commit, and benchmarked in a sandbox with and without the skill, so you can see the actual Lift before you equip anything.

Until agents can predict their own spend, governance has to come from outside the model. Measure the behavior, not just the bill — and test any skill that claims to fix it before you trust it with your budget.

ctaText: Skills, proven. Join the SkillzBench waitlist for free, security-scanned, benchmarked agent skills at launch.

socialProofText: Every skill tested with and without, Lift published in percentage points — always free, and money never touches scores.

The Skills and Architecture That Actually Cut the Waste

The fixes work, but the evidence behind them is messier than the marketing suggests. Every waste pattern above has a documented countermeasure — and almost every countermeasure comes with a benchmark you should read carefully before trusting.

Start with structure. A multi-phase skill plugin that forces agents through clarify, design, plan, code, and verify phases was benchmarked at 9% cheaper and 14% fewer tokens across 12 sessions — six with the plugin, six without. That is a real but modest result from a small sample, and the same article's headline "70 percent" figure comes from tool-maker claims, not its own test.

Output-side skills show wider ranges. According to a DataCamp survey of token-reduction tools, the documented fixes include:

• Caveman — cuts output verbosity by up to 65% fewer tokens (methodology unspecified)
• Ponytail — 54% less code and 22% fewer tokens across 12 coding tasks, self-reported
• RTK — filters command output for 60–90% less token usage on common dev commands
• Context Mode — compresses 315 KB of raw tool output to 5.4 KB, a 98% reduction, vendor-reported

Architectural patterns complement the skills. Prompt caching discounts repeated context by up to 90% (Anthropic, vendor-reported), and bounding accumulated input plus retry paths reduced cost by 28.6% to 44.1% in one cited study. Context eviction and summarization matter too: uncontrolled sessions balloon from 2,000 tokens to 25,000+ without eviction, while summarizing tool results turns a 2,000-token response into a 100-token summary.

Here is the honest part. Documented savings span 14% to 98%, and the methodologies are frequently small-sample, vendor-run, or simply unspecified — which is exactly why independent verification matters. SkillzBench is building a free directory and MCP connector that pins every skill to a commit SHA, security-scans it, and benchmarks it in a sandbox with and without the skill, publishing Lift in percentage points separately from ratings. Join the waitlist to get free, security-scanned, benchmarked agent skills the day we launch.

How to Start Fixing Token Waste This Week (and Where to Find Skills Worth Trusting)

You don't need to fix all nine waste patterns at once. The agents that burn the fewest tokens got there incrementally — one skill, one measurement, one workflow change at a time.

Start with a single compression skill. In one hands-on comparison, tool-output compressors like Context Mode shrank 315 KB of raw tool output to 5.4 KB — a 98% reduction — while command wrappers like RTK cut command-output tokens by 60–90%. Pick one, run a handful of real tasks with it, and measure before adding the next.

And measure the right thing. Cost-per-token is a lagging, noisy metric — Stanford research found the same agent on the same task can vary up to 30x in total tokens. Better signals are behavioral:

• Tool calls per task — in one controlled test, providing decision-grade context dropped calls from 80 to 29 and turns from 50 to 19.
• Repeat-read ratio — how often the agent re-reads files or re-searches facts it already had.
• Retry loops — how many times an agent re-attempts before hitting a wall it can't see.

Match structure to the work. A structured multi-phase workflow (clarify, design, plan, code, verify) earns its keep on ambiguous, new work — where a small benchmark study found misunderstanding a task costs far more than a few clarifying questions upfront. For fast iterative tweaks, skip the ceremony; the overhead isn't worth it.

Here's the catch: skills demonstrably change agent cost and behavior, but quality varies wildly — self-reported benchmarks range from 14% to 98% savings, and published research found roughly 26% of skills carry at least one vulnerability. You need a way to tell which skills actually help.

That's why SkillzBench is building a free, independent directory that pins every skill version to a commit SHA, security-scans and license-checks each one, and benchmarks every skill in a sandbox — same model, with and without the skill — publishing the Lift in percentage points separately from ratings. Advertising funds it; money never touches scores.

Join the waitlist and get scanned, benchmarked skills free at launch.