This guide covers the eight strategies that actually move the needle, ranked by impact, with code and configs you can apply today.

Where Your Tokens Actually Go: The 45/25/20/10 Breakdown

I’ve found that most teams cannot answer the first question: what fraction of my token spend is waste? The numbers from every published source converge on the same distribution for agentic coding workloads:

The first two categories — 70% of total spend — are pure overhead. The model re-reads the same files and the same conversation on every single turn. Fixing those two things alone cuts your bill in half.

1. Prompt Caching: The 40-90% Discount

Prompt caching is the single highest-ROI change you can make. Both Anthropic and OpenAI discount cached input tokens by 50-90%:

• Anthropic: $0.30/M input tokens cached vs $3.00/M uncached (90% off). Auto-enables for repeated prefix content since Claude Opus 4.7.
• OpenAI: 50% discount on cached tokens since GPT-5.5. Requires explicit cached_tokens parameter.

The implementation is deceptively simple but easy to get wrong:

The cache key is the prefix. If your system prompt changes even slightly between calls, the cache misses and you pay full price. Keep your CLAUDE.md and AGENTS.md files stable within a session. I’ve seen teams accidentally include the current timestamp in their system prompt — that single detail invalidates every cache hit.

Real data: Prompt caching alone can cut total input costs by 40-90% depending on how much of your prompt is static prefix (full breakdown).

2. Model Routing: The 70/20/10 Rule

The second biggest lever is not using a frontier model for every task. The data across RouteLLM (ICLR 2025) and AgentMarketCap shows that agentic workloads break down into three tiers:

• 70% simple tasks: Lint fixes, doc generation, simple refactors, test writing
• 20% moderate reasoning: Bug diagnosis, API integration, architectural decisions
• 10% complex architecture: System design, cross-cutting refactors, novel solutions

Route the bottom 70% to small models ($0.10-0.50/MTok), 20% to mid-tier ($1-5/MTok), and only 10% to frontier models ($15-60/MTok). RouteLLM demonstrated 85% cost reduction while maintaining 95% of GPT-4 performance on the Agentic Coding benchmark.

# Simple router example
def route_task(task: str, complexity: str) -> str:
    routing = {
        "simple": "claude-sonnet-4-20260514",   # $3/MTok
        "moderate": "claude-opus-4-8-20260601",  # $15/MTok
        "complex": "claude-fable-5-20260609",    # $60/MTok (before ban)
    }
    return routing.get(complexity, "claude-sonnet-4-20260514")

If you use an AI gateway like Portkey or LiteLLM, set up routing rules at the proxy level so individual developers do not need to think about model selection. The proxy inspects the request metadata and routes accordingly.

3. Context Compression: The /compact Habit

A typical agent session after 30 turns has accumulated 25,000-35,000 tokens of conversation history. Most of it is irrelevant to the current task — the model re-reads every prior thought, every tool result, every error message from 20 turns ago.

Claude Code’s /compact command summarizes the conversation to its essential state, dropping old turns. Use it every 15-20 messages. For other tools, the same principle applies: summarize, don’t append.

For prompt-level compression, tools like LLMLingua achieve 20-50% token reduction by removing redundant tokens from the prompt while preserving semantic content. The trade-off is a slight increase in latency (100-500ms for compression) and occasional loss of nuance in highly technical prompts.

When compression hurts: If your prompt contains precise version numbers, exact error messages, or specific code snippets, compression can drop critical detail. Only compress instructional and explanatory text, not data.

4. AGENTS.md Progressive Disclosure: 70% Token Reduction

This is the most underused optimization. Most teams dump every instruction, every convention, every workflow into a single AGENTS.md file. The agent loads the entire file at session start and re-reads it on every context window reset.

The fix is modular progressive disclosure: keep the top-level file as a thin index with brief skill descriptions (~155 tokens for 4 skills), and load full content only when a skill is triggered:

Each skill gets its own file (AGENTS.d/code-review.md, AGENTS.d/testing.md, etc.) loaded only when the agent needs it. SmartScope documented a 70% token reduction and 5x speed improvement with this approach.

5. AST-Level Dependency Mapping: 65% Without Changing Models

This one is counter-intuitive: you can cut tokens by two-thirds without switching to a cheaper model. The trick is replacing grep-based file search with precise AST-level dependency mapping.

Nicola Alessi documented a case study on a 200-file TypeScript project. With grep-based search, the agent read 40 files per query (8,200 input tokens). After switching to vexp (a Rust-based AST dependency mapper), it read 5 precisely-targeted files (2,100 input tokens) — a 65% reduction.

The mechanism: instead of searching for “all files containing calculateTotal”, the AST mapper resolves the actual import graph and reads only the files that calculateTotal depends on. The agent gets the same information with 80% fewer files.

# Before: grep-based file search
rg "calculateTotal" --type ts  # finds 40+ files

# After: AST dependency resolution
vexp calculateTotal --src ./src  # resolves to 5 files

6. Retrieval-Based Memory: 51-72% on Memory Tokens

Memory systems are the silent budget killer. Naive memory injection dumps every stored memory entry into context on every call — 24 entries = 594 tokens. After a week of usage, that balloons past the useful context window.

Retrieval-based memory injects only the top 5-10 relevant entries per query. Mem0’s 2026 Token Optimization Playbook benchmarked this at 594 tokens naive vs 166 tokens with retrieval — a 72% reduction. The trade-off: you need a vector store and a semantic similarity query per turn, adding ~200ms latency.

The practical setup: implement a cost alert that fires when memory context exceeds 20% of your total input tokens. That is the threshold where retrieval-based memory pays for itself in under a week.

7. MCP Server Optimization: 50-98% on Structured Data

MCP tool responses are the most bloated data in the agent stack by volume. A single list_files response can dump thousands of lines of JSON. Three techniques fix this:

• Compact schemas: Remove unused fields from tool response schemas. Most MCP servers return every field whether the caller needs it or not.
• TOON encoding: MindStudio demonstrated 90-98% reduction on repeated structured data by switching from JSON to a pipe-delimited compact format.
• Response summarization: Have the MCP server return a summary line before the full payload, so the agent can decide whether to read the detail.

I have seen an MCP server that returned 12KB of JSON per file listing call. After compact schemas and summarization, it was 600 bytes. The agent made the same decisions either way.

8. Session Management: 5-15%

The smallest savings but the easiest to implement. Three rules:

• One task per session. When you switch tasks, start a fresh agent session.
• Run /compact or equivalent before switching tasks within a session.
• Reserve pay-per-token API calls for focused execution. Use flat-rate subscriptions (Copilot, Codex Spark) for exploratory work.

The 5-15% range is small because it overlaps with the bigger strategies above. But it costs nothing and takes five minutes to adopt, so there is no reason not to do it.

The Token Efficiency Decision Tree

Which optimization should you apply first? It depends on your setup:

The Stanford Digital Economy Lab found that the same agentic task can vary 30x in token consumption between runs with zero correlation to output quality. If you are not measuring, you are guessing.

Putting It All Together: What a $3,200 → $1,100 Bill Looks Like

Beam published a real-world breakdown for a solo developer:

The total: $3,200 → $380/month — an 88% reduction. The same pattern scales for teams: a 20-person org went from $47K to $16.5K using the same strategies.

None of these strategies require switching tools or frameworks. Every technique works with Claude Code, Cursor, Windsurf, Copilot, Codex CLI, or any other agent. The waste is structural, not tool-specific.

For a deeper look at measuring and attributing these costs in multi-agent production systems, see the agent cost circuit breaker guide.

FAQ

How much does a single developer spend on coding agents per month?

A solo developer running Claude Code full-time spends $3,000-$13,000/month in API costs. With the optimization strategies in this guide, Beam documented a reduction from $3,200 to $380/month — an 88% cut.

Can I use these optimizations with any coding agent?

Yes. Every technique works with Claude Code, Cursor, Windsurf, GitHub Copilot, Codex CLI, Cline, or any other agent. The waste patterns are structural to how agentic coding tools work, not specific to any vendor.

What is the single fastest way to reduce token waste?

Measure first with token cost attribution, then apply the strategy matching your setup. If your AGENTS.md is over 200 lines, progressive disclosure gives 70% savings. If the agent reads whole files on every call, AST-level dependency mapping cuts 65%. If you use one model for everything, routing saves 60-80%.

Does prompt caching work with every LLM provider?

Anthropic offers 90% discount on cached tokens (auto-enabled for repeated prefixes since Opus 4.7). OpenAI offers 50% with an explicit parameter. Google Gemini supports it with tiered discounts. The key requirement across all providers: keep your system prompt prefix stable within a session.

Will these optimizations reduce code quality?

No — in most cases they improve it. The Stanford study found 30x variance between runs with zero correlation to output quality. Model routing with RouteLLM maintains 95% of frontier model performance. AST-level dependency mapping gives the agent more precise context, not less.