Anthropic Shares How to Reduce Cost and Improve Performance with Claude

Anthropic has published a practical guide to reducing AI application costs while improving performance on Claude Platform. Released on September 8, 2026, the guidance focuses on three controls that developers can adjust without redesigning their entire application: prompt caching, instructions, and effort.

The central argument is that Claude costs depend on more than model pricing. Applications can waste money by repeatedly processing identical context, carrying instructions written for older models, or assigning maximum reasoning effort to requests that do not need it.

Those problems also interact. Changing an effort setting can invalidate a prompt cache. A redundant verification instruction can trigger extra tool calls. A stale reasoning template can interfere with a newer model’s native capabilities. Effective optimization therefore requires developers to examine the complete request path rather than one token counter in isolation.

Anthropic’s Optimization Advice Targets Three Cost Centers

Anthropic’s recommendations address three different types of compute waste.

Prompt caching reduces the cost of repeated input processing. Instruction audits remove unnecessary model behavior, including duplicated reasoning and excessive tool use. Effort calibration controls how much deliberation Claude performs before producing an answer.

The distinction matters because each problem requires a different remedy. Shortening a prompt will not help much if an agent repeatedly uses maximum effort. Lowering effort will not repair a cache that misses because a timestamp changes in every request. Switching to a cheaper model may even reduce quality without addressing the architectural source of the expense.

The more useful optimization target is therefore cost per successful task. That includes input tokens, generated tokens, thinking tokens, tool calls, latency, errors, retries, and the application’s actual success rate.

Prompt Caching Pays Only When the Prefix Stays Stable

Before Claude generates an answer, it processes the input into an internal state during a stage known as prefill. When an application repeatedly sends the same long system prompt, tool definitions, documents, or conversation history, that input would normally need to be processed again on every request.

Prompt caching stores the resulting key-value cache so Claude can reuse it when a later request begins with the same prefix. According to Claude’s prompt-caching documentation, cache reads can reduce both time to first token and the cost of processing repeated input.

The pricing illustrates why this can matter. Anthropic lists five-minute cache writes at 1.25 times the normal input price, one-hour writes at twice the input price, and cache reads at 0.1 times the base input price. Ignoring output costs, that implies a five-minute cache can pay for itself on the second use of a prefix. A one-hour cache generally needs a third request before it becomes cheaper than processing the same input normally.

Getting those savings requires the cached prefix to remain stable. The cache is tied to a specific model, while the reusable portion of the prompt must match exactly. Its ordering matters because the Claude Messages API constructs requests from tool definitions, the system prompt, and messages in a fixed sequence.

Common causes of avoidable misses include:

• Adding a dynamic timestamp, request ID, or session value near the beginning of the system prompt
• Reordering or modifying tool definitions between requests
• Switching models in the middle of a conversation
• Changing effort when the selected model treats effort as part of the cached prefix
• Forking an agent conversation with a prefix that differs from the parent
• Waiting on a tool or subagent until the cache’s time-to-live expires

Anthropic says select models, including Opus 5 and Fable 5.1, can change effort mid-conversation without breaking the cache. Developers should not assume the same behavior for every Claude model, however.

Several design changes can make cache hits more predictable:

• Place stable content first. Keep tool definitions and durable system instructions ahead of changing conversation content.
• Defer infrequently used tools. Claude’s tool search feature supports defer_loading, which keeps deferred tool definitions out of the initial prompt and loads them only when needed.
• Append temporary instructions. Where the model supports it, add a new instruction as a conversation message instead of editing the original system prompt.
• Move the cache breakpoint forward. Automatic caching can apply the breakpoint to the final cacheable block as the conversation grows.
• Pre-warm predictable sessions. Anthropic recommends sending a request with max_tokens: 0, an explicit cache breakpoint, and the same effort setting as the expected workload.
• Choose the TTL around agent behavior. A one-hour cache can make sense when long-running tool calls or subagents regularly exceed the default five-minute window.

Cache hit rate should be treated as a production metric. Claude Console and the cache diagnostics API can show why two requests diverged, which is considerably more useful than trying to infer a cache problem from the total bill.

Legacy Prompts Can Make New Claude Models Worse

Prompts often accumulate patches. A model misses a check, so someone adds “verify twice.” It gives a short response, so the system prompt demands maximum thoroughness. A reasoning failure leads to a mandatory scratchpad and a six-step procedure.

Those changes may have helped an older model, but they can become instruction debt when the application migrates to a stronger Claude release.

Anthropic identifies several prompt patterns that can increase cost or reduce quality:

• Verification rituals that cause Claude to repeat searches or tool calls
• Emphasis boosters that encourage unnecessary detail and investigation
• Fixed scratchpads or reasoning procedures that duplicate native reasoning
• Few-shot examples built around the weaknesses of an older model
• Contradictory rules that a newer model follows more literally
• Retired settings, such as outdated manual thinking configurations

Anthropic tested this problem by planting six anti-patterns in customer-support prompts originally used with Opus 4.8. It then compared the old model, Opus 5 with only the model ID changed, and Opus 5 after running the company’s prompt-audit command.

The company reports that /claude-api prompt-audit reduced costs by 14.6% and increased accuracy by 5.3% on average. The savings came from eliminating repeated reasoning and excess tool calls. Accuracy improved because the audit removed incompatible settings, conflicting refund rules, and scratchpad instructions that sometimes caused tool calls to appear in reasoning without being executed.

These are vendor-run results from deliberately constructed prompts, not a guarantee that every application will receive a similar improvement. The experiment still demonstrates an important migration risk: changing the model ID without reviewing the prompt can carry old workarounds into a system that no longer needs them.

Teams should version prompts alongside application code and rerun evaluations whenever they upgrade a model. Instructions, tool descriptions, few-shot examples, and Claude Code configuration files all belong in that review.

Effort Is a Budget Knob, Not a Quality Switch

The Claude effort parameter controls how many tokens the model uses while working through a request. Lower effort generally produces faster, more token-efficient answers. Higher effort gives Claude more room to deliberate, verify evidence, and explore alternatives.

Higher effort can improve difficult tasks, but the relationship is not linear. Anthropic’s FrontierCode Diamond results show Claude Fable 5 scoring 11.5% at low effort for $5.35 per task. At maximum effort, it reached 30.9% for $19 per task. Performance increased by roughly 2.7 times, while cost rose by about 3.5 times.

A separate Humanity’s Last Exam test showed diminishing returns more clearly. Fable 5.1 scored approximately 53% at low effort for around $0.30 per question and 61% at maximum effort for about $2.23. Anthropic says the final increase to maximum effort added only around half a percentage point while raising cost by 46%. That gain fell within the benchmark’s run-to-run variation.

These examples show why effort should be calibrated against the application’s own evaluation set. Maximum effort may be justified when additional searches, checks, or reasoning steps substantially improve the answer. On a saturated task, it can add latency and tokens without producing a measurable benefit.

Setting effort too low creates the opposite failure. An agent may stop after its first search result, skip an important check, or attempt a hard reasoning step without gathering enough evidence. The output can appear complete despite being based on partial information.

A useful evaluation should therefore track at least four variables across effort levels:

• Task success or answer quality
• Total cost per completed request
• End-to-end latency
• Tool-call count and failure rate

Developers can then route routine work to lower effort while reserving higher settings for tasks that benefit from additional deliberation. Model and effort should be tested together because a stronger model at low effort may offer a better cost-quality balance than an older model working harder.

Cache behavior must also be included in that calculation. If changing effort invalidates a valuable cached prefix, the added input-processing cost could outweigh savings from lower reasoning usage. Anthropic suggests making model or effort changes around compaction or another event that already rewrites the cache.

Claude Code Can Automate More of the Optimization

Anthropic has added several optimization workflows to its Claude API skill for Claude Code.

The /claude-api prompt-audit command scans prompts, tool descriptions, skills, application code, and configuration files for legacy instructions and known anti-patterns. This makes it useful during model migrations, although developers should still validate each proposed edit against a representative test set.

Two related commands address broader configuration choices:

• /claude-api hillclimb evaluates combinations of models and effort levels, using separate training and validation tasks to search for a better configuration.
• /claude-api cost-optimize examines application usage or request-building code, identifies major cost sources, and ranks possible changes such as caching, output limits, batching, and prompt cleanup.

These tools turn optimization into a repeatable engineering process rather than a manual prompt-editing exercise. They do not replace domain-specific evaluations. A cheaper configuration is only useful if it preserves the behavior that users, customers, or downstream systems rely on.

A Practical Rollout Plan for Claude Applications

Teams do not need to change every setting at once. A staged process makes it easier to identify which optimization produced a real improvement.

1. Establish a baseline. Measure task success, cost, latency, tool calls, input tokens, output tokens, thinking tokens, and cache hit rate.
2. Stabilize the prompt prefix. Remove volatile values, normalize tool ordering, defer rarely used tools, and select a TTL that matches the application’s request pattern.
3. Audit instructions. Remove outdated reasoning rituals, contradictory rules, excessive emphasis, and model-specific settings that no longer apply.
4. Sweep effort and model choices. Test representative tasks across several configurations rather than assuming one effort level should handle all traffic.
5. Deploy with production monitoring. Watch for cache misses, longer responses, extra tool calls, declining success rates, and unusual behavior on edge cases.

Only one major variable should change at a time during initial testing. Otherwise, a simultaneous prompt, model, cache, and effort update can make it difficult to explain why cost or quality moved.

The evaluation metric also needs to reflect the product. Benchmark accuracy may suit a classification API, while an agent may require successful task completion, correct tool use, and adherence to business policy. Token reduction by itself is not a meaningful win if it produces more retries or support escalations.

Final Thoughts

Anthropic’s most useful point is that AI cost and performance are often two sides of the same engineering problem. Reprocessing stable context, forcing unnecessary verification, and overthinking simple requests consume tokens precisely because the application is asking Claude to do work that does not improve the result.

Prompt caching offers the most direct savings when requests share large, stable prefixes. Prompt audits become especially important during model upgrades, when old workarounds can turn into liabilities. Effort tuning requires more careful evaluation because both extremes can fail: maximum effort can waste compute, while minimum effort can produce confident answers from incomplete evidence.

The strongest Claude configuration will not be the one with the shortest prompt or lowest effort setting. It will be the configuration that spends additional compute only where an evaluation shows that the extra work improves the completed task.