I pulled the logs on three months of my own AI sessions. Every call, every token. The bill wasn't where I assumed it was, and the fix has nothing to do with typing less.
Here's the thing that took me embarrassingly long to internalize: the API is stateless. There's no conversation sitting on a server somewhere that the model can glance back at. Every single call re-transmits the whole pile: your chat history, every file it's read, every screenshot you took, every command's output. Caching makes that re-send about ten times cheaper per token, and it's still the biggest line on the bill, because the volume is enormous.
So I've started thinking about context as rent. When you pull a file into a session, you haven't paid for it once. You've signed a tenant. It sits in the window and you re-pay for it on every call that follows, right up until the session ends or the context gets purged. Read a 50,000-token file early in a session that runs a thousand calls, and you'll have paid roughly 50 million tokens for it by the end.
My biggest session ran 6,940 API calls and burned 3.56 billion tokens. Book editing, builds, scrapes, quick fixes, all of it living in one window that never ended. The chart below is that session's actual per-call context, pulled straight from the transcript. Watch it climb to the million-token ceiling, hit auto-compaction (where the tool summarizes old history to make room), and then climb right back up. Eight times.
Every tooth tells the same story. Rent compounds until the landlord forces a reset. The average call in there was hauling around 500K tokens of context, and most of it was stale tool output and files whose moment had passed hours earlier.
Now for the sneaky part. Plot that session cumulatively and you get a beautiful straight line, which reads as "all good here." A straight line just means the per-call cost pinned itself at the maximum and stayed there. An efficient session draws a straight line too, five to ten times shallower. The slope is the whole diagnosis.
What clicked for me is that "use fewer tokens" isn't a real instruction. Different work wants a differently shaped session, and the money leaks when you mix the shapes without noticing. Almost everything I do fits one of these three.
Across 20,487 tool calls, one humble tool accounted for 87% of everything that entered my contexts: plain old file reads. 2,733 of them pushed about 37M tokens of file text into sessions, and every one of those then sat in the window collecting rent for hundreds of calls afterward. The tool built to prevent exactly this, handing the reading to a subagent whose context gets thrown away, got used 451 times in three months. My least-used lever was my highest-value one.
I run automated guardrails now: a hook that warns me when context crosses 300K, 600K and 850K, plus a forced purge at 250K instead of riding to the million-token ceiling. Automation caps the damage. It doesn't do the work. Every real saving below comes from a decision a human makes at one of three moments: before a session starts, before a file gets read, and after something ships.
This is the one that cost me the most. My marathon session was doing careful book editing, which legitimately needs a huge window, and then in the same window I'd run a build, debug a scraper, ask a quick question about an invoice. Each of those little jobs got charged the book's 500K context, on every call, for no benefit whatsoever. The book work wasn't the problem. Hosting the other five jobs inside it was.
So now there's a ten-second decision at the top: is this assembly line work or studio work, and does the session I'm currently in actually serve it? If the context in front of me doesn't earn its keep for the new task, that task gets its own session. "While I've got you here" is the single most expensive phrase in this whole game.
Reading a whole 2,000-line file to change one function is the most common way people quietly torch a budget. The file lands in context at maybe 25K tokens, you use 40 lines of it, and then you pay for all 2,000 lines again on every subsequent call. Searching first turns that into a couple hundred tokens of match output plus a 60-line read.
The rule I use: any file over about 300 lines gets located before it gets opened. Search for the symbol, get line numbers back, read a window around them. If it turns out you need more, you can always read more. You can't un-read.
Investigations are where context goes to die. "Where is X handled?" means opening six files, five of which turn out to be irrelevant, and all six stay in your window for the rest of the session. A subagent runs that same search in its own throwaway context and hands back the two sentences you actually wanted. The six files never touch your main window at all.
My rule of thumb is anything spanning more than two or three files gets delegated. My data says I did this 451 times in three months when it should have been thousands. If you change one habit off this list, make it this one.
Auto-compaction fires when the window is full, which means it's summarizing at the worst possible moment: mid-task, with no idea which threads still matter. You get a summary that keeps whatever fits. Compacting yourself right after something ships gives you a summary built around a natural boundary, when the finished work is genuinely finished and safe to compress.
Milestone lands, write the state to a file, purge, start the next thing. That single sequence is what turns the sawtooth into the flat assembly line pattern.
In a studio session carrying 600K of context, every message you send re-pays that whole 600K. Five drive-by questions asked one at a time cost five times what the same five questions cost bundled into one turn. It feels chattier to fire them off as they occur to you, and it's the most expensive kind of chatty there is.
I keep a scratch note open during heavy sessions and let questions pile up until I have three or four, then send them together. Same answers, one fifth the cost.
Anything an agent produces, any report, any draft, belongs in a file. Then the main session reads back the two-paragraph synthesis rather than the twelve pages that produced it. The full output is still there when you want it, sitting on disk where it costs nothing per call instead of in a window where it costs on every call.
There's a second payoff. Saved state is exactly what makes the next fresh session cheap to start, which is what makes habit one affordable in the first place. The two habits hold each other up.
Renaming variables, reformatting a file, tagging a list, running a bulk edit: none of that needs the top tier. Blended across my three months, the cheap tier ran about $0.38 per million tokens and the frontier tier ran $1.77. Same job, four and a half times the price. Subagents take a model setting, so the cheap tier can do the grunt work inside a session that's otherwise on the good model.
Where it pays to spend up is judgment: architecture, debugging something genuinely weird, writing that has to be good. The chart below shows how the tiers actually shook out for me.
Your project instructions file, your memory index, every connected tool's schema: all of it gets injected before you've typed anything. It's small per session and you have hundreds of sessions, so it compounds quietly in the background. Mine had accumulated a year of one-off notes that no longer described anything true.
Once a month I read the instruction file top to bottom and cut anything that isn't still load-bearing, then check which connected tools are actually earning their schema. Fifteen minutes, and it pays out on every session I run after it.
Three months of blended cost, meaning what my tokens genuinely cost per million across cache reads, writes and output, makes this part simple. Within any given tier the newer generation comes out ahead: same or lower effective price, plus it's smarter, and the smart part compounds in a way the price tag never shows. A sharper model finishes in fewer calls, wanders down fewer dead ends and re-reads less, so you're buying efficiency alongside the intelligence.
| Metric | Before (measured) | Target |
|---|---|---|
| Median context per call | 317K | under 150K |
| Sessions over 500M tokens | 8 in 3 months | 0 to 1 a month, declared |
| Multi-file reads delegated to agents | roughly 0% | most of them |
| Compactions per session | up to 8 | 0 to 1 |
| Monthly tokens, same workload | 10B to 17B | 5B to 8B |
None of this asks you to be less ambitious or work shorter days. The same three months of output, shaped properly, runs about half the cost, and the model gets to think with a cleaner window the entire time. That second part might matter more than the money.
Coming next: two follow-ups that get specific. Building the assembly line, with the folder structure, the search commands and the exact prompts I use. Then running a studio session properly, which is a different discipline entirely.
The Artificial Advantage: the frameworks behind everything here, written for professionals, not programmers.