Claude Code sends 33k tokens before reading the prompt; OpenCode sends 7k

What really burns tokens is sub agents. I once gave Claude Code a pretty big task, and it immediately launched 7 sub agents which burned through my budget before even one of them was finished. Tried again 5 hours later: same result.

If I let the main agent do the same task sequentially, it was no problem at all. I don't know if it's really just communication and orchestration that makes sub agents so inefficient, or if Anthropic figured that most people using sub agents pay per token on a big corporate account, so this is an easy way to make more money from tokenmaxxers.

My opinion is that claude code uses more tokens simply because Anthropic makes more money that way and forces people into their subscriptions. This is supported by the fact that they won't let you use your sub on a different coding agent. I use pi btw.

UPDATE:

After reading PUSH_AX's valid comment: ``` This is like saying contractor (A) asked for $33,000 to undertake the work and contractor (B) asked for $7,000 Are we measuring and caring about the right thing? ``` We will update the post to include:

1) A more in-depth task. 2) Qualitative results comparison. 3) As soon as possible, a reproduction of the inputs and outputs.

This isn’t limited to large system prompts. Coding-agent harnesses are also becoming more aggressive about using tools, even for trivial requests. In our tests, prompts such as “Hey” or “commit” sometimes triggered 30+ tool calls:

https://quesma.com/blog/the-true-cost-of-saying-hi-to-an-ai-...

Tokenflation seems very real: the number of tokens consumed by simple tasks keeps increasing.

Recently switched to Codex after 6m in Claude. Codex seems more open, it’s easier to follow what the model is doing and the approvals have a better UX. Overall, it just feels more transparent. Cost of switching was close to 0.

I don’t like that Claude became more opaque around February, including the system prompts. 33k feels way too much.

And pi agent is even less.

The entire agent system prompt can be seen here:

https://github.com/earendil-works/pi/blob/main/packages%2Fco...

I am forced to use cloude code at work but a good solution is to just use --system-prompt "" and be done with it. I wish they allowed for other harnesses.

Why don't we have some equivalent of "fork" if we are talking the same context and tokens, you'd think that could all just be loaded into the gpu.

A harness is a part of the intelligence stack. It's no longer about raw access to the model

Also, I have seriously used most harnesses - One feels like it's being built in a place that truly understands AI and where agentic engineering is headed. You might not like it, but peak performance exists in CC when it comes to orchestration of bulk parallel work / subagents. The open source agents are catching up or accell in different way (Im preferable to pi.dev), but I'm not sure they're architecting orchestration the right why.

Early on in experimenting with local models, I found that hooking them up to Claude Code worked very well, but it was also really slow.

I used mitmproxy (setup assisted by Claude, natch) to capture Claude Code's entire initial system prompt and the whole thing was (I just double-checked) 162k of JSON.

This led me to start experimenting with Pi, OpenCode, and Hermes...

Nothing about the time taken to complete the task? Users are definitely sensitive to time, not only token consumption.

> based off of a hunch

This is posed as some sort of discovery, but both Claude Code and OpenCode display token usage clearly after starting a chat or agent, and 30k and 7k is exactly what you see.

Claude Code is not just a harness. It is a different product. You pick the smallest subscription that allows you to do your work. My “multiplier” on a $100 subscription is 5+.

If you’re using API, on the other hand, there is absolutely no reason to use Claude Code, or Codex.

pi sends 1k (or less) -> https://github.com/earendil-works/pi/blob/main/packages/codi...

My $20 sub using gpt 5.6 sol thinking-off lasts for hours using pi.

Mine sends even less - https://maki.sh

This is all heading in the right direction. Much of AI coding feels magical. But when the costs begin to accrue we start asking questions. We dig into it and try to understand what's going on. I can't help but feel Anthropic is "token maxing" from its side: it controls the levers and with every version upgrade it can build in its own token growth almost unbeknownst to the user. This actually harms it on the long run because it necessitates a cheaper option.

Is it not a conflict of interest for a model provider to supply the harness? They are not motivated to minimize your costs.

Claude Code sending 33k tokens before reading the prompt is the AI equivalent of a consultant who bills you for the time spent reading your email before they even open it.

The reasoning built into the models matter so much too. I recently swapped my Qwen3.6 27B to ThinkingLabs’ fine tune and it does what it publishes. I cut my token usage in half, which is a big deal since I only get ~20 TPS for token generation.

This is like saying contractor (A) asked for $33,000 to undertake the work and contractor (B) asked for $7,000

Are we measuring and caring about the right thing?

I think this doesn't mean much; the axes that matter are intelligence x dollars x time; tokens by themselves mean nothing.

With Fable being per token instead of on the subs (unless they changed it again?), I decided to test Claude code on OpenRouter where I had some credits, with Opus 4.8 and Fable 5.

I asked both a trivial question (summarize last commit). Opus cost 50 cents, Fable about $1.

That checks out because Fable's twice as much in the API (though I think its emphasis on correctness makes the difference larger for bigger tasks).

But, at $1 per question, I think I will stick to the subscription for now! I was certainly glad GPT-5.6-Sol is included in OpenAI's subscription, and I'm curious if they'll be able to do the same for GPT-6.

All the VC money appears to have run out a few weeks ago.

I've been trying various harnesses like Pi, OpenCode, Qwen Code, and Nanocoder. A common problem I keep running into is failed tool calls, regardless of the model. What is the best harness and on-device model combination right now?

I feel like this article isn't saying much. Even with tools disabled, Claude Code still has a crap load of commands and other things that Claude (the model) should know the availability of since it's optimized for them. All of that has to be disabled if this is to be a real harness comparison. And of course the system prompt can be completely replaced, making it a no-brainer to use a more minimal prompt similar to OpenCode. And beyond that nothing else really matters because the rest (cache behavior, etc) lies with the provider's platform, not the harness.

Grok 4.5 is really fast, has more usage at $10/month than $20/month Claude pro, and Opus-level. Claude pro feels like a demo.

Claude is much better in OpenCode then in Claude Code, OpenCode is just better than Claude Code. Claude Code feels like a complete mess to use comparatively.

that makes sense, claude code actually does inflates token usage

not even surprised

Why don't people fix their costs (rent a gpu) and just write their own harness (about 200 lines of code).

Supposed to be hacker news and half the posts are like "this harness steals this" like it cant be avoided.

These API costs are mad.

Sorry for asking here, but nobody seems to know.

If I self host a local model is there some way to make Android studio not time out after 10 minutes?

I recommend that Opencode users try Dynamic Context Pruning as well: https://github.com/Opencode-DCP/opencode-dynamic-context-pru...

It works great for long-horizon tasks, and feels like it saves a boatload of tokens.

No surprise, I've noticed that "agents", not only CC (I am using Copilot) are trying to be "clever", searching for a lot of data. This is good for LLM providers as this eats a lot of tokens.

Anthropic wants to produce the best coding agent possible and doesn’t care (is even incentivized) about high costs. Other harnesses have to make trade offs between performance and cost.

So? it doesnt matter, after the first turn it's cached. We are probably talking about single digit cents.

[dead]

[flagged]

[flagged]

> Claude Code 2.1.207 and OpenCode 1.17.18, both pinned to claude-sonnet-4-5

So not only is this article AI-written, but the testing was entirely done by AI, too? I can't see any other reason to use such an old model.

> Our traffic passes through a local LLM gateway that wraps requests in its own envelope, a constant we measured at roughly 6,200 tokens with bare calibration requests

Why do you need to do calibration requests to figure out how your own gateway is affecting requests?

> Its subagent lane did not complete cleanly through our gateway

> We attempted to toggle extended thinking in both harnesses and are declining to publish numbers. Our gateway applies its own thinking policy, neither harness's toggle demonstrably survived the path, and anything we quoted would be noise.

Why is your own gateway screwing with your testing?