Agent Skills That Actually Reduce Token Usage (Not Just Hype)

Skills that reduce token usage are pre-built modules that compress AI agent output, prune conversation history, route tasks to cheaper models, and cache repeated context. They typically reduce an agent's token bill by 50-80% without changing what the agent does.

"I'm trying to reduce token usage, but I haven't found any good Skills that help." That Reddit post has 340 upvotes because most skills ADD tokens. Here are the five patterns that actually cut them.

My Claude Code bill last month was $87. Not outrageous. But when I broke down where the tokens went, the math was depressing.

About 40% was filler. "Certainly! I'd be happy to help you refactor that function. Let me walk you through the changes step by step..." That preamble costs money. It adds nothing. Multiply it by 200 interactions and you're paying for a polite assistant who won't stop explaining things you didn't ask to have explained.

Another 30% was re-prompts. The agent built the wrong thing because the instructions were ambiguous. I described the fix. It rebuilt. Two round trips instead of one. Double the tokens for the same output.

The last 30% was actual useful work.

Here's the uncomfortable truth about agent skills and token usage: most skills increase your token consumption. They add context. They add instructions. They add quality checks. All of which cost tokens. The question isn't "which skills reduce tokens?" It's "which skill patterns change the token math in your favor?"

Five patterns. Tested. Measured. Here's what actually works. These skills reduce token usage and save you money on every agent call.

Do skills actually reduce token usage?

Yes, but not all of them. Skills that compress output, prune conversation history, or route work to cheaper models directly reduce the tokens consumed per call. Skills that add functionality (web search, file reading, tool calling) increase token usage, because they add tool schemas and tool results to the context.

The net effect depends on which skills you install. The five skills listed below are specifically designed to reduce total token consumption, not add features.

How to Reduce Token Usage on Your AI Agent

Before picking specific skills, understand where your tokens go. A typical agent call has four parts, and each one consumes tokens:

1. System prompt (your agent's instructions): usually 300-800 tokens, sent on every call.
2. Tool and skill schemas: roughly 100-200 tokens per tool, sent on every call.
3. Conversation history: grows with every turn, and is often the biggest cost.
4. The model's response: billed as output tokens, which cost 5x the input rate on Claude.

The fastest ways to cut your bill:

Shorten your system prompt. Every word in it is sent on every single call. A 500-word prompt (about 650 tokens) costs roughly $0.0013 per call on Claude Sonnet 5.5, or $0.26 a day at 200 calls. Small on its own, but it scales with every agent and every call. Cut it to 200 words and that line drops by 60%.

Limit conversation history. Most agents don't need the full history on every call. A sliding window of the last 3-5 turns cuts context by 70-80% on long conversations. Trimming an 8,000-token history to 2,000 tokens saves $4.80 a day at 200 calls on Claude Opus 5.5.

Load only the tools you need. If your agent uses MCP tools (Model Context Protocol), each tool schema adds 100-300 tokens to every call. An agent with 10 MCP tools sends 1,000-3,000 tokens of schemas on every request, even if it never uses most of them. Load only the tools the agent needs for its current task, not every tool in your registry. (Pattern 4 below covers MCP pruning in depth.)

Use cheaper models for simple tasks. Classification, tagging, and routing don't need a frontier model. Claude Haiku 5.5 ($0.10/$0.50 per million tokens for prompts up to 100K tokens) costs 97.5% less than Claude Opus 5.5 ($4/$20), which makes routing worth more than it was a month ago.

Then use the skills below to optimize what's left.

What Token Reduction Actually Saves You (In Dollars)

Here's what a typical agent costs before and after optimization, at 200 calls a day:

These numbers use Anthropic's API pricing as of October 2026 (Claude Sonnet 5.5 at $2/$10 per million input/output tokens, Claude Opus 5.5 at $4/$20) and don't include prompt caching, which would lower both columns further. Even without model routing, the context and output cuts alone take the Opus-only bill from ~$304 to ~$87 a month. Route the simplest 70% to Claude Haiku 5.5 instead of Sonnet and the after column drops further still. BYOK users on BetterClaw pay the provider directly at these rates, with zero markup.

Skills That Reduce and Save Tokens

Token Optimization Skills

There's no single skill literally called "Token Optimizer." Token optimization comes from a few skills that each attack one part of the bill, and together they do the job:

1. Output compression (the community "Caveman" skill, Pattern 1): strips filler from every response, saving 65-75% of output tokens per message.
2. Context injection and history pruning (Pattern 5): replaces raw, repeated project context with a condensed summary and keeps only the recent turns that matter, cutting repeated context by 90%.
3. MCP server pruning (Pattern 4): unloads tool definitions the agent isn't using, which can save up to 18,000 tokens per turn per server.

Best Claude Skills to Reduce Token Usage

If you're using Claude (Sonnet or Opus) as your agent's model, these three skills have the biggest impact on your bill:

1. Response compression skill. Claude is verbose by default. A compression skill that enforces short, direct responses cuts output tokens by 65-75% per response. Output tokens are the expensive ones: 5x the input rate on both Sonnet 5.5 and Opus 5.5.
2. Selective history skill. Claude's context window is large (1M tokens on Sonnet 5.5 and Opus 5.5), but you pay for every token in it. A history-pruning skill that keeps only the last 3-5 relevant turns reduces context cost dramatically.
3. Model-routing skill. Route simple classification tasks to Sonnet 5.5 ($2/$10 per million tokens) instead of Opus 5.5 ($4/$20), or to Haiku 5.5 ($0.10/$0.50) for the simplest ones. For tasks that don't need deep reasoning, Sonnet handles the job at half the cost and Haiku at a fortieth.

Pattern 1: Output compression (the "Caveman" approach)

The most talked-about token optimization right now is a skill that forces the agent to communicate in terse, direct language. The community calls it the "Caveman" skill. It strips every response of filler phrases, polite openers, transitional sentences, and step-by-step explanations you didn't ask for.

Without compression: "I've successfully completed the refactoring of the authentication module. The changes include updating the token validation logic, restructuring the middleware chain, and adding comprehensive error handling. Here's a detailed walkthrough of each change..." That's 45 tokens of pure wrapping around the actual content.

With compression: "Auth module refactored. Token validation updated. Middleware restructured. Error handling added." Same information. 12 tokens.

The numbers: A typical response runs 300-500 tokens without compression. With aggressive compression, the same response runs 80-150 tokens. Over 30 exchanges in a session, that's 9,000 to 12,000 tokens saved. Towards AI benchmarked the pattern at 75% reduction per session. Anthropic's own data shows a task that took 15 back-and-forth messages and 12,000 tokens without a skill took 2 questions and 6,000 tokens with one.

The catch: compressed output reads cold. For code generation and technical work, that's fine. For customer-facing content or anything where tone matters, you want the full output. The skill should be toggleable, not permanent.

Pattern 2: First-pass accuracy (get it right the first time)

Here's the pattern that nobody talks about because it doesn't look like a token optimization. But it's the biggest one.

A skill that catches bugs before you commit means fewer "fix the bug I just introduced" conversations. Each bug-fix round trip consumes tokens. A skill that knows your project's testing framework generates tests that pass on the first run instead of requiring "the test fails, fix it" follow-ups. An architecture skill that knows your conventions prevents the agent from generating code in the wrong pattern, which you then have to ask it to redo.

The math: Every re-prompt costs a full round trip. The agent re-reads the context, processes the correction, and generates a new response. One re-prompt on a 30,000-token context costs 30,000+ tokens in re-read plus 500+ in generation. Prevent one re-prompt per session and you save more tokens than any output compression skill.

MindStudio benchmarked five token-cutting skills and found the pattern consistent: fewer misunderstandings lead to fewer re-prompts lead to fewer tokens. Explicit planning leads to less context re-loading. Verification during the session leads to fewer bugs caught afterward and fewer follow-up sessions.

The highest-ROI token reduction isn't making responses shorter. It's making responses correct the first time. One prevented re-prompt saves more tokens than 20 compressed responses.

This is why agent skills that encode your project conventions matter so much. A skill that tells the agent "use functional components, never class components" prevents a wrong-architecture generation that costs 50,000+ tokens to fix.

Pattern 3: Code scripts over markdown instructions

This one's counterintuitive. Most skills are written as markdown: natural language instructions that the agent reads and follows. Makes sense. The agent understands language.

But MindStudio published data showing that executable code scripts reduce tokens by up to 90% compared to markdown instructions for the same task. Why?

Markdown instructions are verbose by nature. "When the user asks you to process data, first check if the file exists, then read the contents, then validate the format, then..." That's a paragraph of instructions the agent reads and interprets on every invocation.

A code script does the same thing in 10 lines of actual code. The agent doesn't need to interpret instructions. It runs the script. Less reading, less reasoning, less token consumption.

The additional benefit: code scripts are more reliable. Natural language instructions leave room for interpretation. "Validate the format" means different things depending on the model's mood. A script that checks isinstance(data, dict) and 'id' in data does exactly one thing, every time.

For skills that perform a consistent, repeatable action (data processing, file management, API calls, format conversion), write them as code scripts. Save markdown instructions for skills that genuinely need flexible interpretation.

Pattern 4: MCP server pruning (the invisible token drain)

Each MCP server connected to your agent loads its tool definitions into the context window. Every message. Every turn. Whether or not you use those tools in this particular interaction.

MindStudio measured the overhead: a single MCP server can cost up to 18,000 tokens per turn in tool definition overhead. Connect three feature-rich MCP servers and you're burning 50,000+ tokens per conversation on tool schemas the agent never calls.

One analysis found that MCP tool definitions can consume 24% or more of the available context window before a single conversation message is sent. That's not a skill costing tokens. That's infrastructure eating your budget. For some tools, direct API calls instead of MCP avoid the overhead entirely.

The fix is simple but often overlooked: unload MCP servers you're not actively using. If today's task doesn't need the GitHub integration, disconnect it. If you only need Slack for this session, don't also load Jira, HubSpot, and Google Drive. (For more on where MCP fits versus skills, see our guide on agent Skills vs MCP.) BetterClaw lets you tick only the tools the agent needs on each MCP server, which is the same pruning without the config edit.

Anthropic addressed this partially in January 2026 with MCP Tool Search. In current Claude Code it's on by default: MCP tools are deferred and discovered on demand instead of all loading up front (ENABLE_TOOL_SEARCH=auto restores the old "only past 10% of context" behaviour). Not every agent framework does this, though, and Claude Code 2.1.296 (9 October 2026) doubled the default limit on MCP tool descriptions sent up front from 2,048 to 4,096 characters. Longer allowed descriptions mean more tokens per tool anywhere tools load eagerly, so pruning matters more, not less. The underlying tension remains. The fewer MCP connections you load, the more context remains for actual work.

This is one area where managed platforms have a structural advantage. On BetterClaw, smart context management handles skill and integration loading automatically. Unlimited skills are available but only the ones relevant to the current task consume context tokens. No manual MCP pruning. No 18,000-token tool definitions sitting in every message. Free plan with 1 agent and 100 credits a month. $49/month on Pro. BYOK with zero markup.

Pattern 5: Context injection over context re-sending

The AI Context Stack pattern (popularized by an open-source GitHub repo in 2026) addresses the most wasteful token pattern of all: re-sending the same project context in every conversation.

Project structure: 800 tokens. Dependencies: 600 tokens. Coding standards: 400 tokens. Architecture decisions: 700 tokens. API docs: 500 tokens. Previous decisions: 400 tokens. Total: 3,400 tokens sent at the start of every single conversation.

Ten conversations per day: 34,000 tokens wasted on repeated context. Monthly: over 1,000,000 tokens that represent zero new information.

The solution: store context in a persistent, efficient format and inject it on demand rather than re-sending it raw every time. This is fundamentally what prompt caching does at the provider level (Anthropic's 90% discount on cached tokens). But you can also implement it at the skill level by structuring your context as compressed, pre-processed summaries rather than raw files.

The pattern: instead of loading your entire project README (2,000 tokens), create a condensed context summary (200 tokens) that captures the critical decisions and conventions. The agent gets what it needs to work correctly in 10% of the tokens. If it needs the full document, it can request it.

The meta-pattern: compound savings

These five patterns don't just add up. They compound.

Output compression cuts per-response tokens by 65-75%. First-pass accuracy eliminates 30-50% of round trips. Code scripts reduce instruction overhead by up to 90%. MCP pruning recovers 24%+ of context window. Context injection eliminates 90%+ of repeated context.

Apply all five and the total reduction is dramatic. A session that would have consumed 150,000 tokens might consume 25,000-40,000. Same work. Same output quality. 75-85% less cost.

Gartner projects 40% of enterprise applications will embed AI agents by end of 2026. As adoption scales, the teams that optimize their token economics today are the ones who can afford to run more agents, more frequently, on harder problems. The teams that don't will hit Uber's wall: budget exhausted before the year is half over.

The best token optimization isn't a single skill. It's a system: compress output, prevent re-prompts, use code over markdown, prune connections, and cache context. Each one saves a little. Together they change the economics. (For the model-selection side of the same problem, see how model routing reduces AI costs and our broader guide to cutting agent API costs.)

Give BetterClaw a look if you want token optimization handled automatically. Smart context management that prevents bloat by design. Free plan with 1 agent and 100 credits a month. $49/month on Pro for 5 agents, with a kill switch on every plan. We handle the token economics. You handle the agent logic.

Frequently Asked Questions

What are token-reducing agent skills?

Token-reducing agent skills are configuration patterns or SKILL.md files that decrease the number of tokens an AI agent consumes per session. They work through five mechanisms: output compression (forcing terse responses, saving 65-75% per message), first-pass accuracy (getting tasks right on the first attempt to prevent costly re-prompts), code scripts over markdown instructions (up to 90% reduction), MCP server pruning (removing unused tool definitions that consume 18,000+ tokens per turn), and context injection (caching repeated context instead of re-sending it).

How much do token-saving skills actually reduce costs?

Individual patterns produce measurable results: output compression saves 65-75% per response (benchmarked by Towards AI), code scripts save up to 90% versus markdown (MindStudio), and MCP pruning can recover 24%+ of context window (Damian Galarza). Applied together, these patterns compound to 75-85% total session reduction. Anthropic's own data shows a task that took 15 messages and 12,000 tokens without a skill took 2 questions and 6,000 tokens with one.

How do I implement an output compression skill for my agent?

Create a skill instruction that directs the agent to use minimal language: no filler phrases, no polite openers, no step-by-step explanations unless explicitly requested. The "Caveman" pattern is the most popular implementation. Add instructions like "respond with maximum information density, no pleasantries, no transitional sentences." Make it toggleable so you can enable full responses when tone matters (customer-facing content, presentations). Average savings: 300-500 token responses compress to 80-150 tokens.

Are token-saving skills worth it on BetterClaw's free plan?

Yes. BetterClaw's free plan includes 100 credits per month. Token-reducing patterns stretch those credits further because each task consumes less from your BYOK API budget. Smart context management is built into the platform (no manual MCP pruning needed). Unlimited skills, including the curated verified library, are a Pro feature, and skills are loaded on demand rather than always present in context. At $49/month for Pro with 12,000 credits a month, the token savings from proper skill patterns can reduce your monthly API bill by 75-85%.

Can token-saving skills degrade output quality?

Output compression (Pattern 1) reduces explanatory context, which is fine for code generation but can reduce readability for written content. The fix: make compression toggleable. First-pass accuracy (Pattern 2) and code scripts (Pattern 3) improve quality while reducing tokens, so there's no tradeoff. MCP pruning (Pattern 4) only affects tokens, not quality, as long as you keep the servers you actually need connected. Context injection (Pattern 5) can degrade quality if summaries are too aggressive. Start with 50% compression and validate output before going further.