Reasoning models are getting better, and over the next six months they'll get better still. That's the good news.
The bad news is that inference cost goes up with them. Reasoning is the expensive part, and you're about to want more of it.
"I'll just run local" only answers some of this. Local works for tasks that need less reasoning. For something like agentic coding, which needs more, it isn't there yet.
So the durable move is habits. These six are what keep my bill where it is, and conservatively they'll cut yours by half.
1. Prompt caching, first and always
Highest return for the least effort, and it's the one people skip. Every major provider supports it, either on the API call or as an account setting.
Cached input runs around 50 cents per million tokens. Uncached, the same content is roughly $5.
That's a 90% saving for a configuration change.
The rule that makes it work: static content goes first in your prompt. System prompt, few-shot examples, tool definitions, anything passed in repeatedly.
Caching stops at the first token that differs. Put something variable near the top and you've thrown away the cache for everything below it.
2. File hygiene, which mostly means stop sending PDFs
PDFs are the default way people hand documents to a model, and they're close to the worst option available.
Roughly 90% of the tokens in a PDF go to layout, fonts, and encoding. Things the model does not care about. About 10% is the actual text it uses.
Now compound it. You aren't sending that file once. You're sending it every turn of the conversation. And nobody uses one PDF. On a real project I might reference 40 or 50 documents: specifications, decision records, design notes.
The same content that's 5,000 tokens as markdown can be 50,000 or 60,000 tokens as a PDF. Convert to markdown and you drop about 90% of the payload while the model gets everything it needs.
3. Say no to the plugin tax
Integrations, connectors, and everyone's favourite, MCP servers.
Loading every server into context is a handyman carrying the entire toolbox across the workshop because they need a hammer. Except worse, because the handyman makes that trip once. You pay for the toolbox every single turn.
Fifty or sixty thousand tokens of tool definitions, re-sent constantly, for tools you won't touch in this session. Load what the session actually needs.
4. Drop model loyalty
"I'm an Opus person." "I'm a Sonnet person." Neither is an engineering position.
Not every job needs advanced reasoning. Picking the right model per job saves an enormous amount.
How I do it: baseline with the model I know works, then Goldilocks down. Try cheaper, check quality against the baseline, keep going until quality stops being acceptable, then step back one.
You're triangulating off a known-good result instead of guessing. The question isn't which model is best. It's the cheapest reasoning that solves this particular problem.
5. Version your prompts, and keep them small
No monolithic prompts. Don't build one giant prompt carrying every instruction for every situation.
Write it, test it, make it as modular and small as it can be, test again, and version as you go so you can see what each change did to the output. Pair that with evaluation testing so "acceptable" is measured, not felt.
One thing that costs more than people realise: models want to be verbose. If you don't need the extra explanation, say so explicitly. You are paying for every sentence of it.
6. Conversation discipline
The most common expensive habit is researching, planning, and implementing in the same chat.
The objection is always the same. "All my context is in that chat." It isn't context, though. By turn 40 or 50 most of it is extraneous, and you're carrying all of it into every implementation turn.
What I do instead is start fresh and load an ADR, an architectural decision record. It holds what I was solving, why, the options I considered, why I rejected the ones I rejected, and why I chose what I chose.
That last part matters more than it looks. It stops the model from drifting into an approach I already turned down, which is exactly what happens when you hand it a long chat with abandoned ideas in it.
ADRs are one way. Specifications work too. Whatever you use, store it as markdown, which is habit two doing double duty.
The habit underneath the habits
Notice that five of the six are about what you put in front of the model, and only one is about which model you picked.
That ratio is the actual point. People argue about models because it's the visible decision. The bill is decided by the boring stuff nobody posts about: what order your prompt is in, what format your files are, how much of your toolbox you dragged along.
And there's a version of this that goes one level deeper. Habits fail because they depend on somebody remembering. So the strongest move is to stop relying on memory and enforce it: a hook that reads the right file before the work starts, tools that carry the practice inside them so nobody has to learn the platform first.
A habit you have to remember is a habit you will eventually skip.
The ones that survive are the ones something else enforces.
What the six habits cost you
None of these are free. They are cheap next to the bill, which is not the same thing.
Caching makes iteration more expensive, not less. Static content first means every edit to your system prompt invalidates the cache below it. The habit that saves 90% in production punishes you while you are still tuning, right? Tune first, then lock the order.
Markdown conversion loses things PDFs carry. Tables survive badly. Figures, signatures, and form layout do not survive at all. On a contract or a scanned form, the 90% you stripped included something somebody needed.
Loading only what the session needs means guessing up front. You will guess wrong, hit a tool you did not load, and restart. That restart costs more than the tool definitions would have.
Goldilocks-down only works if you can measure quality. Stepping the model down without an eval is not cost optimization. It is quality reduction you have not noticed yet. The measurement is the expensive part and it is not optional.
Modular versioned prompts need somewhere to live. A registry, composition logic, and a way to know which version produced which output. That is a small system, and small systems get maintained by whoever wrote them until they leave.
ADRs are work before the work. Writing the decision record, the options, and the paths you rejected happens at the moment you would rather be building. That is the honest price of a clean fresh session.
When to ignore all six. You are experimenting, your bill is in the tens of dollars, and the habits would cost more time than they save money. Come back when the number starts mattering.
What it adds up to
Twelve to thirteen ongoing agentic workflows, three to four agencies, roughly $500 a month.
Some local AI is in the mix, but that's not where the saving comes from. It's habits around token economics, and every one of them is available to you today.
The video version. I Run 4 Agencies on a $500/Month AI Bill, with the numbers walked one habit at a time.
Everything above stands on its own.
Chris