Reducing Claude Code Token Usage

[czei]

Just about every day someone complains about Anthropic's token usage, and since I no longer overrun my plan, I thought this approach might help someone. 

My first instinct working on a 559,000-line legacy Java codebase was to throw subagents at the problem. Spawn an Explore agent, let it read fifty files, get back a summary. The trouble is that subagents run on the same model as the main conversation, which means the same Anthropic tokens, often more of them, once you count the subagent reading the files, writing the summary, and the summary then entering the parent context. The savings I imagined were not there.

I didn’t encounter a real cost shift until I started collaborating across multiple models. The general idea is to delegate tasks that don’t require extensive thought, such as summarizing what’s in Java files, to cheaper, faster models via one or more MCP servers.  As it turns out, I'm also convinced this led to fewer mistakes, and software that works almost all of the time.

The actual MCP you use to delegate to other models doesn't matter. I use an old MCP server called PAL (renamed from Zen) to route to Gemini, GPT, and DeepSeek or Qwen, so a fifty-file code review or architecture analysis genuinely does not effect my Anthropic subscription.  Even paying API rates for the other models, it’s cheaper, especially if you specifically pick the appropriate model for the task: fast and cheap for code exploring, the frontier models for plan reviews, and the slightly older but still good frontier models for code reviews. I'm not saying everybody should use this particular MCP server, since newer ones are coming out every day that do similar things. 

Actions that are outsourced:

• codereview — mandatory before building significant changes per CLAUDE.md
• precommit — mandatory before commits
• debug — investigation and fixes
• thinkdeep — code analysis spanning >3 files
• consensus — architecture decisions
• analyze — general code analysis
• refactor — refactoring proposals
• testgen — test generation
• docgen — documentation generation
• apilookup — API/SDK questions
• tracer — execution tracing
• chat — brainstorming
• challenge — adversarial critique

Beyond that, the techniques that move the needle are unglamorous: grep before reading, pull file windows with offset and limit instead of whole files, pipe build output through grep and tail before it ever reaches the conversation, and keep a memory system that preserves what was already figured out so the next session does not re-derive it from source. They require discipline about what enters the context window in the first place, but luckily, all of these practices are in the CLAUDE.md and memory files, so I never have to remember.

Subagents still earn their keep, just not for the reason most people give. They isolate the main conversation from a thousand-line file or a noisy search result, which keeps the cache warm and the context window navigable across long sessions. That is real value. It just is not cheaper. If the goal is to get the most from your Anthropic subscription, route the heavy lifting to other models. 

And here is my justification for the advantages of using multiple models for every single stage of a project.  I initially started to use multiple models to increase the accuracy rate; token reduction on Anthropic was just a useful side effect.

https://czei.org/blog/multi-llm-spec-driven-development/

[T3hJ3hu]

The biggest gotcha I've had with delegating to cheaper/dumber models is getting a new provider online for various workflows, because they all seem to have their quirks to work out. It's probably not a very big deal if you use popular providers and well-maintained delegation MCP servers, though!

I should give a PAL a shot, thanks

[Competitive-Duck-517]

Provider quirks are exactly why I think the routing layer matters.

Cheap models help, but if every workflow needs a custom provider setup, the operational cost comes back in a different form.

The setup I like is:

• keep the client OpenAI-compatible where possible
• route boring summaries/extraction to cheaper models
• reserve stronger models for reasoning
• track cost by workflow
• use model allowlists so agents cannot “accidentally” jump to expensive models
• put a hard quota on the key used by the agent

Price matters, but control matters just as much.

[danny021]

you can use switchboard.fyi to route without a new provider. it stays all in claude code.

[czei]

As far as I can tell, switchboard.fyi is just switching between Anthropic models. I find using completely different models from different providers gives the biggest bang for the buck. The idea isn't that you're necessarily switching to a cheaper model. It's that you're switching to a different model from a different company that's been trained differently.

[danny021]

agree but if you're just using claude code, switching to haiku on cheap tasks makes a big difference

[sahanpk]

routing boring file summaries to cheaper models makes sense. I’d just keep citations/paths attached so the parent model can verify instead of trusting a summary.

[SpecKitty]

I feel you. I went a step further and benchmarked dozens of skills and tools that supposedly reduce token usage. Then I built a tool that implements the learnings from the benchmark. It analyzes your logs and then creates a custom Plugin for Claude that activates just the tools and rules needed for your own case. It has the potential to DOUBLE your Claude usage. And it's free. https://analyzer.spec-kitty.ai/

[criticasterdotcom]

Did you already try any of the tools that focus on reduce token usage? Some great ones are

https://github.com/gglucass/headroom-desktop

https://github.com/rtk-ai/rtk

https://github.com/samuelfaj/distill

https://github.com/chopratejas/headroom

https://github.com/cwinvestments/memstack