Claude Code sends 33,000 tokens worth of system prompt + tool definitions for the model to read before we even type anything, while OpenCode uses just 7,000 tokens to do the same job. That’s nearly a 5x difference — meaning every time you open a new session, you’re paying more money and waiting for more latency before any real work even starts. This matters to anyone running agents hard, every day, because this kind of token overhead adds up fast. Over a month, that’s a meaningful chunk of money gone.
Where this question came from
A developer friend of mine told me a story: one day he opened up the Claude Code usage dashboard just to poke around, and he was stunned. A task as simple as “fix a typo in one file” ate up way more tokens than he expected.
He hadn’t typed anything long at all — just a short sentence — but the bill still spiked. So he started wondering: before AI actually reads our instructions, is there some kind of “hidden cost” lurking underneath?
That’s what led to digging into the actual requests — looking at what system prompt, tool definitions, and context get sent ahead of the user’s actual command, and just how much that really adds up to. I think this is a question every dev using agent tools should ask themselves at least once.
Where Claude Code sits among Anthropic’s tools
In the Anthropic family, we’ve got Claude Desktop for casual chatting, the bare-bones Claude API where devs control everything themselves, and Claude Code — a full-blown coding agent. The deeper you go into “agent,” the more context you have to carry — because an agent needs to know its tools, permissions, and environment before the user even types the first word.
Claude Code chose the trade-off of heavy preloading upfront, so it can respond instantly without needing to go back and forth asking which tools are available. I think this is an intentional design that trades upfront tokens for smoothness during actual work — but you also have to admit it’s more expensive than OpenCode, which chose to load much more sparingly.
| Factor | Claude Code | OpenCode |
|---|---|---|
| Tokens before reading prompt | 33,000 tokens | 7,000 tokens |
What’s hiding behind that 33k-token number, and how does it play out in practice
That 33k figure doesn’t come from nowhere. Most of it comes from tool definitions preloaded in full ahead of time, plus a detailed system prompt that covers every edge case.
If you open a short, single-use session — like a quick debug first thing in the morning — this cost feels very noticeable, because you’re paying the full 33k every single time you open a new one. But if you’re running a long agent loop all day, this cost averages out, since context caching helps absorb it.
What’s more concerning is CI/CD, where the budget per run is limited. Opening and closing sessions rapidly like that means the 33k per round adds up fast. I think if the work involves frequent short-lived tasks, OpenCode is clearly the more economical choice.
| Factor | Claude Code | OpenCode |
|---|---|---|
| Tokens before reading prompt | 33,000 tokens | 7,000 tokens |
| Loading approach | Preloads all tool defs | Loads only what's needed |
Pros and cons of this heavy-preload approach
The upside is that Claude Code has full context from the very start — it knows every tool before work even begins, so it makes more accurate decisions on complex tasks that require switching between tools frequently, without needing to load more mid-task and burn a turn doing it.
The downside is the cost is clearly higher, as the data above shows — 33,000 versus 7,000 tokens, almost a 5x difference. For short, simple work like a general question, you’re paying way more than necessary, and it eats into your context window before real work has even started.
I think this is a trade-off between “always ready” and “always economical” — neither is 100% correct; it depends on what most of your work looks like. If you’re doing complex work frequently, heavy preloading pays off. But for light usage, OpenCode really is more economical.
The hidden cost you don’t see on the cover
Think about it simply: if Claude Code fires off 33k tokens every time before reading a prompt, compared to OpenCode’s 7k — that’s nearly a 5x difference on every single request. The more often you call it per day, the faster that gap compounds, both in cost and in the context window left over for actual work.
Latency takes a direct hit too, because more tokens need to be processed before work even begins — meaning the developer’s wait time before seeing the first result gets longer accordingly.
I think these hidden costs often get overlooked because they don’t show up directly on the pricing page — but they accumulate every day until they become a significant number, especially for teams running automated workflows repeatedly all day long.
Made for
- Teams doing frequent complex work who need context ready to go from the start
- Projects where accuracy matters more than cost per request
Think twice
- Teams calling agents very frequently per day should keep an eye on cumulative costs
Skip this one
- Light, general Q&A work called frequently — consider a lower-overhead alternative like OpenCode
So which should you choose
The 33k versus 7k token comparison isn’t just about “who eats fewer tokens.” It’s a completely different philosophy. Claude Code chooses to stuff context full from the start for accuracy, while OpenCode chooses to stay lean and load more later as needed.
I don’t think either one is wrong — it depends on what kind of work you do. If you’re calling agents all day in complex workflows, the accumulated cost from that 33k-token overhead will show up clearly on your end-of-month bill. But if your work demands high accuracy from the very first prompt and you don’t want to risk losing context, paying a bit more might be worth it.
Honestly, don’t choose based on a single number. Look at how frequently your team’s routine work actually calls these tools, and decide from there.