How to Cut Your AI Bill by 50-90%: The Token-Saving Playbook

There are two ways to spend less on AI, and most people only ever reach for one of them.

The first is the prompt itself: stop padding it, and stop letting the model pad its answers back. That is real and worth building into a habit - we start there. But on its own it only shaves the edges off individual messages.

The second is bigger, and it is where the real money hides: the shape of the work. What gets cached, what runs in a batch, which engine does the job, and how much history you re-pay for on every turn. Get those right and you cut the bill 50 to 90 percent with identical output.

Here is the whole toolkit, cheapest habit first.

First: know what a token actually costs

You cannot cut a bill you cannot read. Every request is priced per token, split into input (everything you send) and output (everything the model writes back), per million tokens:

Two things fall out of that table immediately. Output is about 5x pricier than input, so a model that rambles costs you on the expensive side. And the top model is 5x the price of the small one - which is the third lever below.

# Free, exact, and model-specific - measure before you spend
client.messages.count_tokens(model="claude-opus-4-8", messages=[...])

Start here: talk like a caveman - both ways

The cheapest token is the one you never send. The second cheapest is the one the model never writes back. So cut the filler in both directions.

• Your side: drop the "could you please possibly take a look at..." and just ask. "Why does auth fail on line 23?" does the same job in a fraction of the tokens.
• Its side: tell it to answer like a caveman too - no preamble, no "Certainly! Here is...", no restating your question back to you. Output is about 5x the price of input, so trimming the model's chatter saves you on the expensive side of the bill.

It feels blunt for about a day, then it feels like a superpower. This is the prompt-side lever, and I broke the full version - including Caveman Mode, the open-source skill that strips the filler automatically - down in Caveman Mode and 6 other ways to cut your Claude bill.

Lever 1: Cache the stuff that never changes (up to 90% off)

Most real workloads send the same big chunk of context over and over - a system prompt, a knowledge base, a long set of instructions, a document you are asking ten questions about. Without caching, you pay full input price to re-read that identical block on every single request.

Prompt caching fixes that. The model stores the processed prefix, and on the next request the matching prefix is served from cache at about one-tenth the input price. Writing to the cache costs a small premium (about 1.25x for the default 5-minute window), so the math is simple: if you will reuse the context even twice, caching already wins.

# Mark the stable chunk as cacheable - it is read at ~10% price next time
system=[{"type": "text", "text": BIG_STABLE_CONTEXT,
         "cache_control": {"type": "ephemeral"}}]

There is exactly one rule to respect, and it is where people quietly lose the discount.

Lever 2: Batch anything that is not urgent (50% off)

Not every job needs an answer this second. Overnight report generation, bulk classification, tagging a backlog, generating embeddings, processing a CSV of a thousand rows - none of that is waiting on a human staring at a screen.

For all of it, the Batch API charges half price. You hand over up to a hundred thousand requests at once and they come back asynchronously - usually within an hour, always within 24. Same models, same quality, same features. The only thing you trade is immediacy.

Lever 3: Send the right model, not the biggest one (up to 5x)

Reaching for the most powerful model on every task is like couriering every letter by same-day motorbike. A lot of AI work - classification, extraction, formatting, simple rewrites, routing - is handled comfortably by the small, fast model at one-fifth the price of the flagship.

The move is to route by difficulty:

• Haiku - high-volume, well-defined work: tagging, extraction, simple transforms. Cheapest and fastest.
• Sonnet - the everyday workhorse: most coding, analysis, and generation.
• Opus - the hard, high-stakes calls: deep reasoning, tricky multi-step work, anything where a wrong answer is expensive.

You do not pick one model for the whole app. You pick one per task, and let the cheap model carry the volume while the expensive one handles the few jobs that actually need it.

Lever 4: Stop paying to re-read the same history

Here is the one that quietly dominates a long agent's bill. The API is stateless - every turn, you resend the entire conversation so far. A 50-turn agent session does not pay for 50 messages; it pays for message 1 fifty times, message 2 forty-nine times, and so on. The history is the cost.

Three ways to stop the bleed:

• Compaction - summarize the old part of the conversation into a short digest, so you carry the meaning and not every raw word.
• Context editing - automatically drop stale tool results and finished reasoning that no longer matter, instead of dragging them along forever.
• Subagents - hand a self-contained sub-task to a separate agent with its own fresh context window, so your main session's history stays lean.

In day-to-day Claude Code, the everyday version of this is the /compact and /clear habit. Same principle whether you are clicking or calling the API: the less history you re-send, the less you re-pay.

Level up: let one agent pick the engine

Lever 3 routes between one provider's tiers. The bigger version routes between different AI systems entirely - and lets an agent make the call for you.

On a large build, no single model is best at everything, so stop forcing one to do all of it. Put an orchestrator agent in front that reads each sub-task and hands it to the engine that fits. The way I wire the bigger projects:

• Claude Fable 5 for the hardest reasoning and long-horizon agentic work
• a code specialist like Codex for the security pass
• Gemini for the frontend

The orchestrator decides who does what, dispatches the pieces, and stitches the results back together. You get the right engine on every job instead of paying one flagship to do work a cheaper specialist does better - and the router itself can be a small, fast model, because "this is a security task, send it to the security engine" is a cheap decision to make.

Stack them - the levers compound

These are not alternatives. They multiply.

Take a nightly job that classifies a thousand support tickets. Route it to Haiku instead of Opus (down about 5x), cache the shared instruction block across all thousand (the repeated part drops about 90%), and run the whole thing through the Batch API (another 50% off). Each lever was free to apply, none of them touched a word of your actual prompt, and the output is identical.

Start by measuring - run count_tokens on your heaviest workload and find where the tokens actually go. Then apply the lever that fits: repeated context gets cached, non-urgent work gets batched, easy work gets a smaller model, and long sessions stop re-reading their own history. None of it is hard. All of it compounds.