Where Your Claude Code Plan Actually Goes

My machine has been keeping a receipt for every agent session I've ever run, and for months I never opened it.

Claude Code writes a transcript for each session it starts. It lands in ~/.claude/projects, one file per session, quietly, whether or not anyone ever reads it. Codex does the same thing in ~/.codex/sessions. Those files record what the model was asked, what it answered, and — the part that matters here — how many tokens went in and out, and which model did the work.

That's a meter. It has been sitting on my disk the whole time, ticking, unread.

I noticed because I couldn't answer a question about my own work. I run agents on a VPS most days, across more projects than I can hold in my head at once. What you end up with, building that way, is a set of live things and a rough intuition about which ones are heavy. I wanted to rank them by cost. Not guess — rank. And I had nothing. No number, no ordering, not even a confident sense of whether the expensive one was the big database migration or the small thing I babysit every morning out of habit.

That is what a flat monthly price does. It's not a trick and I'm not complaining about it — a subscription is a genuinely good deal, and predictable billing is worth paying for. But a fixed price removes the meter, and removing the meter removes the feedback. Anything you stop measuring, you stop having opinions about.

So I wrote Gauge. It reads the transcripts your tools already wrote and tells you what they cost.

The invisible-cost problem is a behavior problem

When metered billing goes away, the thing that disappears isn't anxiety about money. It's discrimination — the ability to tell one of your own habits apart from another.

Here's the shape of it. With a per-token bill, you learn quickly that the refactor you ran six times in a row is expensive, and you either decide it's worth it or you stop. With a flat price you run it sixty times and feel exactly the same both ways. The cost is real, it's just been smeared evenly across the month and stamped with one number that never moves. Your behavior drifts, and there's no instrument pointed at the drift.

The drift goes both directions, which is the part people miss. Some of us over-spend without noticing — running a whole agent fleet to do something a grep would have done. Plenty of others under-use what they're paying for, treating a paid subscription like a scarce resource, hand-editing files at 1am because kicking off an agent feels extravagant. Both of those are the same failure. Both come from having no readings.

I want to be precise about what Gauge is, because the category it's closest to is one I don't like. It is not a budget cop. It doesn't warn you, throttle you, nag you, gamify you, or draw a red line you're supposed to feel bad about crossing. There's no goal field. It's a gauge in the dashboard sense — a needle that tells you the truth about a system you're operating, and then gets out of the way while you decide what to do.

The data was already there, and it was already wrong

Reading those transcripts turned out to be more interesting than I expected, in the specific way where "more interesting" means "my first three numbers were badly wrong."

Two things will fool you.

The first is streaming. Claude Code writes one transcript line per streamed chunk, and every one of those lines carries the same message id and the same usage block. If you sum the file line by line — the obvious implementation, the one you'd write in ten minutes and trust — you count a single assistant reply as many times as it had chunks. Sessions also replay earlier messages when you resume them, so a long-running session re-states its own history and you count that too. Naive line-summing doesn't over-count a little. It over-counts catastrophically, and it over-counts most on exactly the long, resumed, heavily-streamed sessions you're most curious about. Gauge dedupes by message id, so each message is counted once no matter how many lines it wore.

The second is where the work actually happens, and this is the finding I'd tell you first if we were talking.

Subagent transcripts don't sit next to their parent. They nest several directories deep, in their own files, under paths you will not stumble across. In my testing, those nested subagent transcripts held roughly half the total spend. Half. Every tool I'd seen that eyeballs a session directory was reporting a number that was quietly missing one out of every two dollars, and the sessions where it was most wrong were the good ones — the deep research sweeps, the multi-agent builds, the runs where you fan out to six workers and let them go.

That's the thing about measuring instruments. The wrong reading is worse than no reading, because a wrong reading is one you'll act on.

The honest-dollar problem

Now the harder part, and the reason I care about this project more than the size of the codebase justifies.

You want a dollar figure. Dollars are the only unit that means anything across projects — you can't compare a Sonnet-heavy afternoon to an Opus-heavy morning in tokens and get anything you'd bet on. But nobody publishes what a subscription plan's tokens actually cost. Plans don't disclose their quota mechanics. There is no exchange rate published anywhere that converts "your Max plan" into "this session cost $X."

So there are two options. Invent a number, or find an honest one.

Everything in Gauge is API-list-equivalent. Every dollar it shows is what that usage would cost at published API rates, if you had run the same tokens through the API instead of through your subscription. That's a real, checkable, publicly documented rate card, applied to real, locally recorded token counts. It's a common currency, and it's the only one available that doesn't require making something up.

It is explicitly not your bill. Gauge says so, on the screen, in the words it uses. If you pay a flat monthly price, your bill is that flat monthly price and no output from this tool will ever change it. What the API-equivalent number gives you is the thing the flat price took away: a stable yardstick you can hold up against two of your own projects and get a true ordering.

The same discipline applies everywhere else in the tool. The five-hour window is the clearest case. Vendors don't expose real plan limits — not the numbers, not the reset behavior, not the shape of the curve. Gauge could have picked a plausible ceiling and drawn a progress bar against it, and honestly, that bar would look great. It would also be fiction, and once a month it would tell someone they had room when they didn't. So Gauge shows your last five hours against the largest five-hour window it has ever actually observed on your machine, labeled as exactly that. An empirical high-water mark, not a limit. On my box the peak reading is $233 API-equivalent, set on 2026-07-22. That's not a rule anyone gave me. It's the most I have ever demonstrably pushed through in five hours, and it's a fair thing to measure a Tuesday afternoon against.

And when a model has no published rate, Gauge shows token counts. Not an estimate, not a "roughly," not a number derived from the nearest similar model with an asterisk. Tokens, plainly, in the column where dollars would have gone. A blank in the ledger is information. A fabricated dollar is a lie with decimal places, and it will get repeated in a screenshot on Monday and quoted as fact by Thursday.

Every one of those three choices makes the tool look less impressive than the dishonest version. That's the trade, and I'd make it again. a-gnt exists to tell people the truth about AI tools, including the ones I write myself, and a measuring instrument that flatters you isn't an instrument. It's a toy with a needle on it.

What it actually shows you

Spend by project, so you can rank your own work. Spend by session, so you can find the one run that ate the afternoon. Spend by model, because the mix matters more than the volume. Daily bars for the last fourteen days, which is the window where you can still remember what you were doing. And the last five hours against that observed peak.

There's also gauge statusline, which prints a single line for Claude Code's statusLine slot. That one combines two different kinds of truth: the burn Gauge measured off your transcripts, and the official plan percentages Claude Code pipes in. Measured usage next to vendor-reported usage, in the same line, all day. You stop needing to go look, which is the whole point of a gauge.

Install is one command:

npx github:joey-io/gauge

Zero npm dependencies. It needs Node 22.5 or newer, because it uses the SQLite that ships inside Node itself rather than pulling a driver. Nothing leaves the machine — no account, no sign-up, no telemetry, no network calls at all. Your token counts are a fairly intimate record of what you've been building, and shipping them to a server so a dashboard can render a chart is a trade I wasn't willing to ask anyone to make. The source is at github.com/joey-io/gauge, MIT licensed.

There's a $3 supporter license. It verifies offline and gives you nothing you didn't already have — every feature works identically without it. The unlicensed copy just says, quietly, that it's unlicensed. That's the whole mechanism. If the tool saved you something and you want to say so, three dollars says it.

What the readings changed

My most recent seven-day total is about $915 API-equivalent. The week before that was near $2,700.

I know why. The $2,700 week was a stretch of heavy multi-agent work, and the by-project breakdown lets me name the handful of projects that account for most of it. That is precisely the sentence I could not construct before I built this. Not "that felt like a lot" — an ordering, with the receipts under it.

The five-hour view has been the surprise. At one point I looked down and saw $124 in the window, which the tool told me was 53% of my observed peak. That reading didn't make me stop. It made me keep going, deliberately, on something worth going hard on, with an accurate sense of what hard actually looks like on this machine. That's the opposite of what people assume a usage meter does to you, and it's why I keep saying instrument rather than budget.

Gauge belongs to a small family of things I build for exactly one reason: I needed the reading and couldn't get it. Page came from the same place — an agent working alone at 3am needs a way to reach a human, so I built the inbox instead of continuing to babysit terminals. Neither is clever. Both are just the missing instrument, made.

Here's the part I'd ask you to try, and it takes about thirty seconds. Run npx github:joey-io/gauge and look only at the by-project view. Don't look at the total — the total is a number you'll have feelings about, and feelings aren't the useful part. Look at the ordering.

Then ask yourself whether the project at the top is the one you'd have named.

My machine had been keeping that receipt for months. The number wasn't the revelation. The ranking was.