I Measured My Tokens Again
3 min read
I've written about my Claude Code usage twice before, both times from a Postgres index that ingests my sessions. This time I wanted to check the index by going around it — straight to the raw transcript files on disk, summing the token counts myself. Same question, different instrument. Here's what fell out.
The count
From 2,608 transcript files spanning April 8 to July 7, across 259 sessions:
- 91,908 assistant turns — the model's actual responses
- 15.58 billion total tokens
- Broken down: 231.9M uncached input · 84.3M output · 1.16B cache writes · 14.1B cache reads
The gap between 2,608 files and 259 sessions is worth a sentence: most of those files aren't top-level sessions. They're subagents and workflow fan-outs — every parallel agent I spawn gets its own transcript. A single session that orchestrates a dozen subagents leaves a dozen extra files behind. The telemetry has a shape, and the shape is "one conversation, many hands."
Six models, one workhorse
I don't run one model. The transcripts show six, each doing a different job:
| Model | Turns | Total tokens |
|---|---|---|
| Opus 4.8 | 53,802 | 10.65B |
| Fable 5 | 12,809 | 2.11B |
| Opus 4.6 | 8,725 | 1.05B |
| Sonnet 4.6 | 10,840 | 0.58B |
| Opus 4.7 | 2,645 | 1.05B |
| Haiku 4.5 | 3,087 | 0.15B |
Opus 4.8 is the workhorse — 59% of turns, two-thirds of the tokens. Fable 5 is the expensive specialist I reserve for authoring. The rest fill in: Sonnet and Haiku for the cheap, high-volume, fault-tolerant work; older Opus versions trailing off as I migrated forward. It's not a model. It's a fleet with a dispatch policy.
The patterns that keep reproducing
Measuring a different way is only interesting if it either breaks a previous finding or confirms it. It confirmed all three of mine.
Bash is still half. Of 52,333 tool calls, 27,641 were Bash — 52.8%. I wrote a whole post about why that number isn't an accident, off a different dataset. It reproduced to within a point. Real work with an agent is mostly operating a computer, not generating prose.
Cache reads are 90.5% of everything. The 14.1 billion cache-read tokens dwarf everything else. An agent re-reads the same context every turn; without prompt caching the economics collapse. This is the single load-bearing number in my whole stack — I gave it its own post, and it's only grown.
One project dominates. Homelab is 28,206 turns and roughly 7.9 billion tokens — about half of all activity — with Cortex, this website, RailMind, and client work splitting the rest. The work has a center of gravity, and it's the infrastructure I use to do the work.
Why re-measure at all
The numbers here differ from my last count — a narrower window, straight from the transcripts, assistant turns only. That's the point. A metric you can only produce one way, through one pipeline, is a metric you're trusting on faith. When the number survives being computed a completely different way — from the raw files instead of the index, by a script I wrote in an afternoon — it stops being a dashboard reading and starts being a fact. Bash is half. Cache is ninety percent. One project is half. I've now watched all three hold across two instruments. Those are the ones I'll build on.