We burn through our monthly Claude Code and Cursor token limits in days. How do we cut agent token usage?
Most of the spend is context the agent re-sends on every turn: the full conversation, rules files loaded at session start, and raw tool output it used. Cut it by clearing between tasks, trimming CLAUDE.md and always-on Cursor rules, keeping bulky tool output out of the main window, and giving the agent a context engine that answers in one call instead of rediscovering the codebase every task.
Agent token usage is mostly context, not conversation. Claude Code's docs say it plainly: "Claude Code sends your full conversation with every request, and each time Claude uses tools it sends another request carrying that batch of tool results" (Claude Code docs). Every file the agent read, every test log it printed, and every rules file loaded at session start is paid for again on each turn. To cut token usage, shrink what rides along: clear between tasks, trim the always-on files, keep bulky tool output out of the main window, and stop paying the agent to rediscover your codebase every task. One correction first: on current plans the limit is a window, not a month. Claude Code Team and Enterprise seats reset on "a rolling five-hour window and a weekly window", and Cursor's included pool "refreshes weekly, so one heavy day doesn't use up your month" (Cursor docs). A few heavy days inside one window empty it.
Where the tokens go#
| Sink | What the docs say | First fix |
|---|---|---|
| Long sessions | A one-line question in an all-day session "still draws usage for the whole conversation" | /clear between tasks |
| Always-on rules files | CLAUDE.md target is under 200 lines; Cursor says keep rules under 500 lines | Trim; move workflows to skills or scoped rules |
| Raw tool output | Claude Code caps one MCP result at 25,000 tokens by default | Hooks and subagents |
| Exploration and retries | Vague prompts "trigger broad scanning" | Specific prompts, plan mode |
| Parallel agents | Each subagent starts fresh and "sends its own requests on top of the main conversation's" | Fewer, smaller agents |
Always-on rules files are the instruction files an agent loads at every session start, such as CLAUDE.md or a Cursor rule with alwaysApply: true. The Claude Code memory docs target "under 200 lines per CLAUDE.md file", since "longer files consume more context and reduce adherence", and imports "don't reduce its context cost" (Claude Code memory docs). Cursor is the same shape: rule contents "are included at the start of the model context", and the docs say to "Keep rules under 500 lines" (Cursor rules docs).
Tool output and exploration#
Anthropic's guide says that "when an agent calls tools, the results become part of the conversation history and count against the context budget on every subsequent turn" (Claude Cookbook, March 2026). Claude Code warns at 10,000 tokens per MCP result and caps it at 25,000 by default (Claude Code MCP docs). For example, a 25,000-token search result the agent reads once is re-sent on every later turn until you clear the session.
Exploration takes the rest. Cursor's Agent has "no limit on the number of tool calls Agent can make during a task" (Cursor Agent docs). Each Claude Code subagent "starts with a fresh, isolated context window" and "doesn't see your conversation history" or "the files Claude has already read" (Claude Code subagent docs). Agent teams "use approximately 7x more tokens than standard sessions when teammates run in plan mode" (Claude Code costs docs, above).
What the vendor docs tell you to do first#
- Measure. In Claude Code,
/usageattributes recent usage to skills, subagents, plugins and individual MCP servers, and/contextshows what fills the window. In Cursor, "Different models draw from the pool at different rates". - Between unrelated tasks, use
/clearrather than/compact./compact"reads the conversation it summarizes, so compacting a large context is itself a large request", while "/clearcosts nothing". - Trim the always-on files. Keep CLAUDE.md under 200 lines and move workflow instructions into skills, which "load on-demand only when invoked". In Cursor, switch rules from
alwaysApplyto glob-scoped or description-triggered. How to fix a bloated CLAUDE.md walks through the audit. - Keep bulk out of the main window. A hook can filter a 10,000-line log to the matching lines, "reducing context from tens of thousands of tokens to hundreds". Hand test runs to a subagent so "only a summary returns to your main conversation". Prefer a CLI such as
ghover an MCP server, and disable servers you are not using. - Match the model and effort to the job: Sonnet for most work, Haiku for simple subagents.
Why the hygiene fixes stop short#
The hygiene fixes shrink the overhead and leave the work untouched. The largest sink is the agent rebuilding the same understanding of your system on every task: which service owns the behavior, why it was built that way, what the last PR changed, what the thread decided. A rules file cannot hold that; it is static and every line costs on every turn. A subagent still has to do the reading; it only keeps the transcript out of your window.
The long exploration also lowers the quality of the answer. Context rot is the drop in a model's ability to recall what is in its window as the window grows. A March 2026 paper finds that LLMs show "significant performance degradation as context length increases" (Cao et al.). Anthropic's guide uses the term too: the discipline is "finding the smallest set of high-signal tokens that maximize the likelihood of your desired outcome". Running the agent longer does not recover it (the auto-loop tax).
Give the agent the answer instead of the search#
A context engine is a service that indexes code, PRs, issues, docs, chat and incidents together, reconciles them, and returns one cited answer, filtered by the asker's permissions. The exploration moves server-side; each agent asks one question instead of re-reading the repository. Unblocked's MCP server exposes two tools: context_research, which "returns a synthesized answer with citations", and context_get_urls for the content behind a link (Unblocked MCP docs). The same server serves Claude Code, Cursor, Codex, VS Code and JetBrains.
We measured the difference on 2026-04-16: same prompt, same model (claude-sonnet-4-6), same production repository, with and without Unblocked attached. With it, the agent used 42 percent fewer tokens and made 29 tool calls instead of 80 (same prompt, same model, different context). One run is not a population; the method is published so you can repeat it. Zachary Goldberg, Engineering Manager at Lilt: "My agents know to use Unblocked first because it's faster than having them figure it out from the code alone. When I'm working on a Java service, I ask Unblocked what documentation exists, what the code says, what the service does — and it comes back with a succinct, clear answer. Individual MCPs are great when you already know what you're looking for. Unblocked is what you use when you need the full picture."
So: measure, clear between tasks, trim the always-on files, move bulk into hooks and subagents, then put a context engine in front of the exploration. Context engine vs direct MCPs covers the difference from wiring GitHub, Confluence and Slack MCPs straight into the agent.
