The Harness Tax
A `claude -p` call bills for its own furniture before your prompt even loads, and the fix that buys 4.4x on a quick call turns out to be almost worthless on a long agentic run, because they're two different taxes.
“Reply with exactly: ok.”
Four words in. One word back. The kind of reply that should cost nothing, or close enough to nothing that you’d never think to check. I ran it through claude -p "Reply with exactly: ok" --output-format json and got back a bill for 28,500 tokens. $0.18. To say “ok.” 🤦♂️😆 (also, what is even in there?)
I’d been using claude -p more and more lately for skill and prompt testing, codex too, which is exactly the kind of thing that makes you start reading usage blocks you’d normally ignore. We’ve all seen this pendulum before: a year or so ago it was tokenmaxxing, throw context at the model and sort out the bill later. Now we’re swinging back the other way, tokens are expensive again, and I’m apparently the guy checking the receipt for a two-word reply.
This is the same territory as context rot and mcps are dead: the AI getting dumber, the invisible costs piling up before you ask a real question. This time it’s the harness itself.
What’s Even In There
That JSON usage block breaks a claude -p call into three numbers worth caring about here: input, the fresh tokens in what you actually send; cache write, tokens the call newly stores in the cache; cache read, tokens the call pulls back from a cache written earlier. Here’s the split from that first run, 2026-07-03: input 9,931, cache write 3,235, cache read 15,291.
My prompt was two words. That cache read is Claude Code’s own system prompt and tool schemas, read back from a cache it wrote before my two-word prompt ever showed up.
Prompt caching is working exactly as advertised. Anthropic’s own pricing page lays out the deal plainly: a 5-minute cache write costs 1.25x the base input price, a 1-hour write costs 2x, and reading it back costs 0.1x (platform.claude.com/docs/en/about-claude/pricing). Cache reads are supposed to be the cheap part. The question is what’s getting cached in the first place, every session, whether I touch it or not.
One Env Var
Claude Code loads a pile of stuff before it ever reads your prompt: your installed skills list, your global CLAUDE.md, plugins, project session memory. It bills all of it fresh, as input and cache write, every single call, whether that call touches any of it or not. On my default config, that “ok” test was the full 28,500 tokens, $0.18: input 9,931, cache write 3,235, cache read 15,291.
Point CLAUDE_CONFIG_DIR at a clean folder, one with nothing but credentials in it, and run the same test:
input 2,945, cache write 1,836, cache read 15,298. About 20k tokens. $0.041.
$0.18 down to $0.041. 4.4x cheaper, for one environment variable.
Notice what that 4.4x is actually measuring, because it tripped me up too: the token count only dropped by about a third, 28,500 to 20,000, but the bill dropped 4.4x. Go back to that pricing table. The tokens that vanished were the expensive kind, fresh input at full price and cache writes at 1.25x. The tokens that stayed are cache reads at a tenth of the rate. Kill the expensive tokens and the cheap ones barely register on the bill. So 4.4x is a dollar number, and it’s the number I carried into everything that follows. Hold that thought.
The Floor That Doesn’t Move
Look at just the cache read numbers: 15,291 on the default config, 15,298 on the clean one. Seven tokens apart. That’s the tell. All of that 4.4x cost drop came out of input and cache write; the cache read didn’t move at all. Strip out every skill, every CLAUDE.md line, every plugin, every scrap of project memory, and that number doesn’t budge.
That’s the floor: Claude Code’s core system prompt and tool definitions. It loads and caches them no matter what config you run. Config can’t touch it. Only a smaller harness would.
It Grew Overnight
I re-ran the same test the next day while poking at an unrelated spike: a local-researcher build running on Pi instead of Claude Code, more on that in a second. Same command, same clean-config-versus-default comparison.
Default config: input 9,900, cache write 7,029, cache read 23,415. 40,344 tokens. $0.080. Clean config: input 2,966, cache write 2,685, cache read 15,298. 20,949 tokens. $0.050.
The floor held exactly: 15,298, identical to the day before. That’s the constant. Everything else moved.
Add up what isn’t the floor, input plus cache write plus whatever cache read sits above that fixed 15,298, and day one comes to 13,166 tokens. Day two comes to 25,046. Nearly doubled. In one day. Without me installing a single new skill.
The Rabbit Hole
Quick receipt before we go further: this isn’t only happening on my machine. Back in April someone filed a bug on the Claude Code repo clocking a clean-environment “hi” at about 31,000 tokens, no repo, no CLAUDE.md, nothing (github.com/anthropics/claude-code/issues/52979). A stale-activity bot closed it in June. Marked “not planned.” Case closed, nobody home.
This is the same rabbit hole I’ve been in for a while now. In the hunt for cheaper per-token models, I ended up writing a prompt-diff tool that runs statistical analysis across different prompts to see which one actually gets you the answer you need for the fewest tokens. Same instinct pointed at a completely different problem: teaching a vision model to read filament colors off my 3D printer. Asking a VLM “what color rolls are in which slot” turns out to be a hard question. Asking it to draw a bounding box around each roll, then joining that against data I already have, works. Same promptdiffing grind, pointed somewhere nobody would expect.
Two Taxes
Two taxes, and let me name them right here instead of making you wait for the reveal. The first is a config tax: everything Claude Code loads before your prompt - skills, CLAUDE.md, plugins, project memory - billed fresh as input and cache write on every call. That’s the one the env var kills. The second is a replay tax: the model rereading its own transcript every turn, which lands entirely in the cache read column and grows with the length of the run. Short calls are mostly config tax. Long agentic runs are almost all replay tax. Same three numbers in the usage block, two different bills - and I was about to bring the config fix to the run that’s nothing but replay.
Then I pointed the same clean-config trick at something that actually matters to me: a real agentic research run, the kind that fans a task out across a maker pass, an adversary pass, and a rework pass, many turns deep. This is what I’d been saving that 4.4x for. If one env var does that much for “ok,” what does it do for the real thing?
That run, measured the same way on the same clean-profile claude -p setup, came back at 48.4 million tokens. 93% of it cache read. About $31 at Sonnet rates.
That 93% cache read is context replay: the model rereading its own growing transcript on every turn. Every new turn resends the whole conversation so far as cached context, and that cost compounds with turn count in a way a one-shot config tax never does.
The clean-profile fix, the same one that cut the “ok” bill 4.4x, bought back about 116,000 tokens here. Out of 48.4 million. 0.24% of the bill.
I strutted in ready to save 4.4x and walked out with a rounding error.
Match the Fix to the Station
Two taxes, two different diseases, two different medicines.
Short sessions pay a config tax: skills, CLAUDE.md, plugins, project memory, reloaded and rebilled every single call. Clean CLAUDE_CONFIG_DIR kills that one. One env var, 4.4x on the bill.
Long agentic loops pay a replay tax instead. Every turn resends the whole conversation so far, and no environment variable trims a conversation. That one needs an architecture fix: shorter windows, summarization, whatever actually stops the model from rereading everything it’s already read.
Underneath both sits the floor neither fix touches: Claude Code’s own core system prompt and tool definitions, about 15.3k tokens, present no matter what config you run or how short your session is. The only way to move that number is a smaller harness. Pi is the minimal-harness reference point here, not a rival to Claude Code, just a different answer to how much does showing up cost. Its own pitch: “Pi is a minimal agent harness. Adapt Pi to your workflows, not the other way around.” Its floor is an authored system prompt, one to three thousand tokens (pi.dev, github.com/earendil-works/pi).
And there’s the option the tidy three-item list skips: run the model on your own hardware, and the marginal token is free, whichever tax you’re paying.
Here’s the deal: the expensive mistake is fixing the wrong tax, and I nearly made it. Trim every skill and CLAUDE.md line before a 48-million-token run and you’ve saved 0.24%. Rebuild your agent’s whole memory architecture to protect two-word calls and you’ve spent a week dodging a $0.14 tax. Both fixes are real. Both are worthless pointed at the wrong bill.
So before you build the next long-running agent or the next thousand-call eval, run one cheap query and read the usage block that comes back. Input and cache write dominating? Config tax, and one env var fixes it. Cache read dominating? Replay tax, and you’re having an architecture conversation. Ten seconds with a JSON blob tells you whether your fix is worth an environment variable or worth a rewrite.