How to Reduce Claude Fable 5 Token Costs: 8 Settings to Change Right Now
Cut your Claude Fable 5 API bill with these 8 practical settings: default model, sub-agent model, claude.md trimming, MCP pruning, and spending caps.
Why Your Claude Bill Is Higher Than It Should Be
If you’re running Claude Fable 5 for any kind of agentic workload — coding, research, multi-step workflows — you’ve probably noticed the token costs add up fast. A single long session can burn through more tokens than you’d expect, especially if you haven’t adjusted the defaults.
The good news: most of the waste is preventable. Claude Fable 5 ships with settings tuned for capability, not cost efficiency. That makes sense for Anthropic — but not necessarily for your budget. With a few targeted changes, you can cut your Claude token costs significantly without sacrificing output quality on most tasks.
This guide covers 8 specific settings to change right now, from model selection and sub-agent configuration to context file trimming and MCP pruning.
Understand Where Your Tokens Actually Go
Before changing anything, it helps to know what’s actually driving your token usage. Most people assume it’s the output — long responses eating up tokens. In practice, the input side is often the bigger culprit.
In agentic Claude workflows, the context window gets loaded with:
- System prompts and instructions
- The
CLAUDE.mdproject file (if you’re using Claude Code or a similar tool) - Tool definitions from every active MCP server
- Prior conversation turns carried forward
- File contents, code snippets, and tool call results
Each of these adds up. And because Claude Fable 5 uses a large context window, it’s easy to fill it without realizing it.
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
The 8 settings below target each of these cost drivers directly.
Setting 1: Change Your Default Model for Routine Tasks
Claude Fable 5 likely defaults to a high-capability model for everything. But most tasks in an agentic workflow don’t need that level of reasoning — file reads, simple edits, status checks, boilerplate generation.
Why this matters
The cost difference between Claude’s tiers is substantial. Using a faster, lighter model for simpler subtasks can reduce per-task costs by 80–90% without meaningfully affecting results.
What to do
In your tool or API configuration, set the default model to the most capable sufficient model, not the most capable model available. Save the heaviest model for complex reasoning steps only.
In Claude Code, you can set this in settings with:
model: claude-haiku-3-5Or in your API calls, explicitly pass a lighter model when the task doesn’t require deep reasoning. A good rule of thumb: if a task can be described in one sentence and has a clear right answer, it doesn’t need your most expensive model.
Setting 2: Configure a Separate Sub-Agent Model
If you’re running multi-agent workflows — where Claude orchestrates other Claude instances to complete subtasks — each sub-agent call can be expensive if they all default to the same heavyweight model.
The orchestrator vs. worker distinction
Your orchestrator (the top-level agent doing planning and synthesis) benefits from a powerful model. Your workers (agents doing retrieval, summarization, formatting) usually don’t.
What to change
Most multi-agent frameworks let you set a separate model for sub-agents. In Claude Code, this is the --model flag on spawned subagents. In a custom API setup, it’s simply passing a different model ID when you create child agent calls.
Set sub-agent model to something like claude-haiku-3-5 or equivalent. Reserve claude-sonnet or the full Fable 5 flagship for the orchestrator layer.
This single change can cut costs on complex multi-step workflows by 40–60%, depending on how many sub-agent calls you make per session.
Setting 3: Trim Your CLAUDE.md File
The CLAUDE.md file (or claude.md in some setups) is a project-level instruction file that gets loaded into the context window on every interaction. It’s useful — but it can become a significant source of token bloat.
What goes wrong
People add things to CLAUDE.md over time: coding standards, project documentation, background context, onboarding notes, historical decisions. None of it gets removed. After a few months, you might have a file with 5,000–10,000 tokens that gets loaded for every single message.
How to audit it
Open your CLAUDE.md and ask: does Claude need to see every line of this on every interaction? Most of the time, the answer is no.
Prioritize:
- Keep: Active constraints, current project structure, tool preferences, file naming conventions
- Remove or archive: Historical decisions, completed work logs, background documentation Claude doesn’t need to act on
- Condense: Long explanations of things Claude already knows about the codebase
A well-maintained CLAUDE.md should be 200–500 tokens. If yours is longer, there’s almost certainly waste to cut.
Setting 4: Prune Unused MCP Servers
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
Model Context Protocol (MCP) servers are how Claude connects to external tools — file systems, databases, APIs, web search, and more. Each active MCP server injects its tool definitions into the context window every time Claude runs.
The hidden cost
Tool definitions are surprisingly verbose. A single MCP server with 10 tools might add 1,000–2,000 tokens to every request, just in schema definitions. If you have 8–10 MCP servers enabled and only regularly use 3 of them, you’re paying for the others constantly.
What to do
Audit your active MCP servers. For each one, ask:
- Did I use this in the last week?
- Is this needed for the current project?
Disable anything that isn’t actively in use. In Claude Code, you can manage this in your MCP settings configuration. In custom setups, remove tool definitions from your system prompt for tools that aren’t needed in the current context.
For project-specific work, consider maintaining multiple MCP profiles — a lean one for coding tasks, a fuller one for research-heavy work — and switching between them.
Setting 5: Set API Spending Caps
This one doesn’t reduce token usage directly, but it prevents runaway costs and forces discipline in how you use the API.
Why you need hard limits
Agentic loops can go wrong. A Claude agent in an unexpected state might loop indefinitely, making hundreds of API calls before you notice. Without a spending cap, that can result in a surprisingly large bill before anything flags it.
How to set them
In the Anthropic console, you can set:
- Monthly spending limits — hard cap on total API spend per billing period
- Usage alerts — notifications when you hit a threshold (e.g., 50%, 80% of your cap)
Set your monthly cap to roughly 150% of your expected usage. This gives you headroom for legitimate spikes without leaving the door open to runaway costs.
If you’re building for others, you can implement per-user token budgets in your application layer by tracking token usage per API key or session and rejecting requests that exceed a set threshold.
Setting 6: Enable Prompt Caching
Anthropic’s prompt caching feature is one of the most underused cost optimizations available. It lets you cache a portion of your input prompt so that repeated calls reuse the cached version, rather than re-processing the same tokens every time.
When it helps most
Prompt caching is most valuable when you have:
- A large, stable system prompt (like project instructions or a knowledge base)
- Long conversation histories you’re re-sending each turn
- Repeated file contents across multiple tool calls
With caching enabled, the cached tokens cost approximately 90% less on cache hits than they would on a fresh call.
How to enable it
In the Anthropic API, you add cache_control blocks to the portions of your prompt you want cached. Mark your system prompt and any large static content with {"type": "ephemeral"} cache control.
The cache persists for about 5 minutes by default, which covers most interactive session patterns. For batch processing or scheduled jobs, you may need to re-warm the cache periodically.
On a workflow with a 4,000-token system prompt that gets sent 50 times per day, this change alone can reduce input token costs by 60–70%.
One coffee. One working app.
You bring the idea. Remy manages the project.
Setting 7: Reduce Max Output Tokens
By default, Claude can generate very long responses. On tasks where you only need a short answer, this doesn’t automatically cause problems — Claude won’t pad responses to hit a token limit. But there are situations where constraining output helps.
When to lower max_tokens
- Tool call responses where you only need structured JSON
- Summary tasks where you want a fixed-length output
- Classification tasks with a small set of possible answers
Setting max_tokens tightly on these types of requests ensures Claude doesn’t over-explain or add unsolicited context. It also gives you predictability in cost estimates.
Be careful not to cut too short
The flip side: if you set max_tokens too low on complex tasks, Claude will truncate mid-response, which usually wastes the entire call. Keep conservative limits on tasks where output length is unpredictable.
A reasonable approach: identify your 3–5 most common request types and set appropriate token ceilings for each, rather than applying a blanket limit.
Setting 8: Configure Conversation Compaction
In long agentic sessions, Claude carries forward the full conversation history in each request. By turn 30 of a complex debugging session, you might be sending 20,000+ tokens of conversation history just to ask a one-sentence follow-up question.
What conversation compaction does
Compaction (sometimes called conversation summarization) periodically replaces older portions of the conversation history with a dense summary. Instead of sending full turn-by-turn history, you send a compressed version of what happened plus the recent turns.
How to implement it
Claude Code has built-in compaction that can be enabled via settings. In custom API implementations, you’ll need to build this yourself — typically by periodically sending a summarization request and replacing older history with the resulting summary.
A simple rule: when your conversation history exceeds 50% of your context window, trigger a compaction pass. Summarize everything except the last 5–10 turns, then continue from there.
This can reduce ongoing per-turn costs in long sessions by 50–80%, since you’re no longer re-sending the same historical tokens over and over.
How MindStudio Handles Token Cost Management
If you’re building Claude-powered workflows and want model selection, cost controls, and context management handled for you, MindStudio is worth looking at.
MindStudio gives you access to 200+ AI models — including Claude Fable 5, Haiku, Sonnet, GPT-4o, Gemini, and others — through a single interface. You can assign different models to different steps in a workflow, so your orchestration layer uses a capable model while retrieval and formatting steps use cheaper alternatives.
Relevantly for this article: you can build multi-step workflows visually, set per-workflow model defaults, and control how much context gets carried between steps. You’re not managing raw API calls and context windows by hand — the platform handles the infrastructure layer, including retries, rate limiting, and context passing.
For teams managing API spend across multiple workflows and users, that visibility is practical. You can see what each workflow costs to run, compare model costs side by side, and adjust without touching code.
You can try MindStudio free at mindstudio.ai.
- ✕a coding agent
- ✕no-code
- ✕vibe coding
- ✕a faster Cursor
The one that tells the coding agents what to build.
Common Mistakes That Undo These Optimizations
Even after making the right changes, a few habits can quietly undo your cost savings.
Not reviewing CLAUDE.md after major project milestones. The file grows. Schedule a quick audit every few weeks.
Leaving MCP servers enabled “just in case.” Disabled servers cost nothing. Re-enabling one takes seconds. Default to off.
Using a flagship model for test runs. When you’re iterating on a new workflow or prompt, use a cheaper model until the logic is solid, then switch to the better model for production.
Ignoring the Anthropic usage dashboard. Check it weekly when you’re actively building. Spikes are usually traceable to a specific workflow or change.
FAQ
How much can I realistically save by changing these settings?
It varies by workload, but combining model tiering (settings 1 and 2), CLAUDE.md trimming (setting 3), MCP pruning (setting 4), and prompt caching (setting 6) typically reduces costs by 40–70% for agentic workloads. Long-session savings from conversation compaction (setting 8) can be even higher. The exact number depends on how misconfigured your current setup is.
Does using a cheaper sub-agent model hurt output quality?
For most sub-agent tasks — file reading, simple edits, structured data extraction, formatting — a lighter model performs comparably to a flagship model. The quality difference shows up on tasks that require complex reasoning, long-range planning, or nuanced judgment. For those, keep the better model. For mechanical subtasks, the lighter model is usually fine.
What’s the best way to audit my MCP servers?
Open your MCP configuration file and list every active server. For each one, check your recent session logs to see how many times it was actually called. Any server with zero or near-zero usage in the past week is a candidate for disabling. You can always re-enable when needed.
Is prompt caching available on all Claude models?
Prompt caching availability depends on the specific model and API tier. Check Anthropic’s current documentation for the latest supported models and caching behavior. As of mid-2025, caching is available on most production Claude models.
How do I know if my CLAUDE.md is too long?
A practical benchmark: if it takes more than 2–3 minutes to read through your CLAUDE.md from start to finish, it’s too long. Another signal: if you can’t remember what’s in it without opening it, there’s probably outdated content that isn’t actively influencing Claude’s behavior.
Can these optimizations be applied to Claude used through third-party tools?
Some can, some can’t. Settings controlled by the underlying API (model selection, max tokens, prompt caching) depend on whether the tool exposes those options. Settings like CLAUDE.md trimming and MCP pruning apply anywhere those features exist. For tools that don’t expose cost controls, consider whether you’d be better served by a platform that does.
Key Takeaways
- Most Claude token cost waste comes from the input side — bloated context, unused tool definitions, and repeated system prompts — not from long outputs.
- Switching sub-agents to a lighter model tier is one of the highest-leverage changes you can make.
- CLAUDE.md and MCP server audits take 15 minutes and can reduce per-session costs immediately.
- Prompt caching is underused and can cut cached-content costs by roughly 90% on cache hits.
- Spending caps and usage monitoring are basic hygiene — set them before something goes wrong, not after.
Remy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
If you want model cost controls, multi-step workflow orchestration, and context management without building it from scratch, MindStudio is a good place to start. It’s free to try and you can have a working Claude-powered workflow running in under an hour.
