Claude Code sends about 26,000 tokens to the model before it reads a single word you typed. MiniMax Code, which went open source last week, sends about 12,600. I measured both on 24 September 2026 with a fake API server on my own machine, no API key, no bill. The gap is real. What it costs you is not what most people think.
This matters because a coding agent is not one chat message. It is a loop that resends that same starting bundle on every single step. If the bundle is fat, every step carries the fat.
Here is the part that surprised me. The money side of that overhead is mostly solved already. The room side is not. Stick with me and you will see why, and you will leave with a 30-line script that lets you measure any coding agent yourself in about ten minutes.
First, what is actually inside a request
Start with the simplest true fact. A language model has no memory between calls. Every time a coding agent wants the model to think, it has to send everything again: who the model is, what tools it can use, and the conversation so far.
That starting bundle has three parts. The system prompt (the hidden instructions that tell the model how to behave, written by the tool maker, not by you). The tool definitions (a written description of every action the agent can take, like “run a shell command” or “edit a file”, each with its own little instruction manual). And the messages (your prompt, plus any context the harness quietly injects, like the date or your project rules).
All of it is measured in tokens (small chunks of text the model reads, roughly three quarters of an English word each). The model’s context window (the maximum amount of text it can hold in its head at once) is counted in the same unit. So every token of overhead is a token of space your actual code cannot use.
Think of it like a suitcase with a fixed size. The airline makes you pack their safety manual before you pack your clothes. A thin manual leaves room for a week of shirts. A thick one leaves you with socks.
Why MiniMax Code vs Claude Code is the comparison worth running this week
MiniMax, the Shanghai lab behind the M3 model, published the source of its terminal agent on GitHub under the MIT license (a permissive license that lets you read, copy, and modify the code freely). TechNode reported the release on 21 September. The repo at MiniMax-AI/minimax-code sat at about 1,800 stars (GitHub bookmarks, a rough popularity signal) when I checked, and the npm package was already on version 0.5.4, released the same day I tested it.
Most early coverage asked “is it as smart as Claude Code?” That question is really about the model inside, not the agent around it. The agent around it is called the harness (the loop, tools, permissions, and memory wrapped around a model). And the harness decides the overhead. A leaner harness gives any model more room to work.
So I asked a narrower question that I could actually answer with evidence. How much does each harness pack into the suitcase before I say anything?
How I measured it without spending a cent
Here is the trick, and it is the most useful thing in this post. Both agents let you change where they send requests. Claude Code reads an environment variable (a setting passed to a program when it starts) called ANTHROPIC_BASE_URL. MiniMax Code lets you add a custom provider that speaks the Anthropic Messages format (the JSON shape Anthropic’s API expects).
So I wrote a tiny fake server. It listens on my own machine, saves every request it receives to a file, and answers “Hi from mock.” Neither agent can tell the difference. They pack their full suitcase, send it, get a boring reply, and exit. I get the suitcase.
// mock.js : run with node mock.js 8788const http = require('http'), fs = require('fs'); let n = 0;http.createServer((req, res) => { let body = ''; req.on('data', c => body += c); req.on('end', () => { fs.writeFileSync(`req_${++n}.json`, JSON.stringify({ url: req.url, body })); let j = {}; try { j = JSON.parse(body) } catch {} const msg = { id: 'msg_1', type: 'message', role: 'assistant', model: j.model || 'mock', content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 1, output_tokens: 1 } }; if (!j.stream) { res.writeHead(200, { 'content-type': 'application/json' }); return res.end(JSON.stringify({ ...msg, content: [{ type: 'text', text: 'Hi from mock.' }], stop_reason: 'end_turn' })); } res.writeHead(200, { 'content-type': 'text/event-stream' }); const ev = (e, d) => res.write(`event: ${e}\ndata: ${JSON.stringify({ type: e, ...d })}\n\n`); ev('message_start', { message: msg }); ev('content_block_start', { index: 0, content_block: { type: 'text', text: '' } }); ev('content_block_delta', { index: 0, delta: { type: 'text_delta', text: 'Hi from mock.' } }); ev('content_block_stop', { index: 0 }); ev('message_delta', { delta: { stop_reason: 'end_turn', stop_sequence: null }, usage: { output_tokens: 5 } }); ev('message_stop', {}); res.end(); });}).listen(+process.argv[2]);Then point each agent at it from an empty git repo:
# Claude Code 2.1.282, clean home folder so none of my own settings leak inHOME=/tmp/cc-clean ANTHROPIC_BASE_URL=http://127.0.0.1:8788 ANTHROPIC_API_KEY=sk-mock \ claude -p "say hi"# MiniMax Code 0.5.4, custom provider pointing at the same kind of serverexport MOCK_KEY=sk-mockmcode provider add --name mock --base-url http://127.0.0.1:8787 \ --api-format anthropic-messages --model mock-model --api-key-env MOCK_KEY --usemcode exec --prompt-mode coding "say hi"For counting, I used the tokenizer file that shipped inside Anthropic’s older Python SDK (version 0.34.2). It is not the exact tokenizer current Claude models use, so treat every number below as a close estimate, not an invoice. The ratio between the two agents is the part to trust. For the official counting API shape, see the Anthropic token-counting docs.
How many tokens does Claude Code use before you type?
About 26,150 in my run. The request body weighed 108 KB. It broke down like this.
| Part of the request | Claude Code 2.1.282 | MiniMax Code 0.5.4 |
|---|---|---|
| System prompt | ~5,990 tokens | ~3,680 tokens |
| Tool definitions | 24 tools, ~18,330 tokens | 18 tools, ~8,240 tokens |
| Injected messages | ~1,830 tokens | ~680 tokens |
| Total before your words matter | ~26,150 tokens | ~12,600 tokens |
| Raw request size | 108 KB | 53.6 KB |
Look at where the weight sits. It is not the system prompt. Tool definitions are 70% of Claude Code’s overhead. The single heaviest tool was Bash at roughly 2,800 tokens, because its manual is long and careful about git safety and quoting. Then came Agent (about 2,000), SendMessage (about 1,400), Workflow (about 1,350), ScheduleWakeup (about 1,200) and CronCreate (about 1,150).
Some of those you will use every day. Some, like scheduling cron jobs, you may never touch. You still carry their manuals on every step.
A widely shared dev.to test earlier this year put Claude Code at 33,000 tokens before the prompt. My number is lower because I ran it in a bare home folder with no MCP servers (Model Context Protocol, a standard plug that lets an agent call outside tools like GitHub or a database), no CLAUDE.md, and no plugins. Your real number is almost certainly higher than mine. Every MCP server you connect adds its own tool manuals to the pile.
What MiniMax Code packs, and the two things that caught my eye
MiniMax Code sent about half the weight. Its heaviest tool was task (about 1,300 tokens), the one that spins up sub-agents. Then website_deploy at about 960.
That second one is odd. I asked a coding agent to say hi in an empty repo, and it brought along the full manual for publishing a website to a public URL. Every request carries it whether you ever deploy anything or not. It is a small tell about who MiniMax built this for: people who want the agent to build and ship a page, not just edit code.
The other detail: before the real request, MiniMax Code called the /v1/messages/count_tokens endpoint twice. It measures its own suitcase before sending it. That is a nice habit, and it is also why you should not panic if you see extra calls in your provider dashboard.
A few more things I found by reading the installed package, because the source is right there. The third-party notices say parts of the terminal interface are derived from Pi TUI, the MIT-licensed interface from Mario Zechner’s Pi agent, and the built-in model catalog comes from models.dev. Inside the injected context, the agent calls itself “Mavis”, which looks like an internal codename. And the package ships 40 skill files, including a whole pack for Lark (ByteDance’s workplace suite) and one called resume-codex that picks up a session you started in OpenAI’s Codex CLI.
Does the overhead actually cost you money?
Less than the raw numbers suggest. Both agents mark the fixed part of the suitcase with cache_control (a flag that tells the API “you have seen this exact text before, reuse it”). I found three of those markers in each agent’s request.
Here is why that matters, from the ground up. The first time a long prefix goes to the model, you pay full input price. On the next step, if the prefix is identical, the API reads it from a cache (a stored copy it can reuse quickly) and charges a fraction of the normal price. Anthropic’s own docs describe cache reads as far cheaper than fresh input. So after step one, those 26,000 tokens get much cheaper per step.
One worry I had going in: would a new harness talking to a custom provider bother with caching at all? It does. MiniMax Code sent the cache markers in Anthropic format. Whether your provider honors them is a question for your provider, not the harness.
So the bill is mostly handled. The room is not.
Why the room matters more than the bill
Caching makes old text cheaper. It does not make it smaller. Those 26,000 tokens still sit inside the context window on every step.
Go back to the suitcase. Say the model can hold 200,000 tokens. Claude Code’s bare overhead takes about 13% of that before your first file is opened. MiniMax Code’s takes about 6%. Add a few MCP servers and a long CLAUDE.md and that share climbs fast.
Why should you care? Because when the window fills, the agent has to compact (summarize older parts of the conversation to free up space). Compaction loses details. The file you discussed forty minutes ago becomes one vague sentence. That is when agents start re-reading files, forgetting decisions, and repeating mistakes you already fixed.
Now the fair counterpoint. Bigger overhead is not waste by default. Claude Code’s Bash manual is long because it teaches the model not to force-push or skip hooks. The Agent and Workflow tools exist so the main session can hand heavy work to helpers that burn their own windows instead of yours. A thin harness can be thin because it trusts the model more. That is a design choice, not a free win.
My take: overhead is worth paying when you use what it buys. The tools you never call are the pure tax. If you have never scheduled a cron job from your coding agent, you are hauling that manual for nothing.
Can MiniMax Code read my CLAUDE.md and skills?
Yes, and this is the most practical finding if you are thinking about trying it alongside Claude Code.
I dropped a CLAUDE.md with a marker word into the test repo. MiniMax Code picked it up and put it into the request. I also placed a skill in .claude/skills/ with its own marker, and MiniMax Code listed that too. So your existing Claude Code house rules and skills mostly come along for free.
Then I found a gotcha. With both CLAUDE.md and AGENTS.md in the same folder, MiniMax Code 0.5.4 sent only the CLAUDE.md content. AGENTS.md was silently ignored. Remove CLAUDE.md, and AGENTS.md loads. The README tells you mcode init writes AGENTS.md, so a lot of people will end up with both files and wonder why their new rules do nothing.
Going the other way, Claude Code 2.1.282 loaded AGENTS.md when no CLAUDE.md existed. That lines up with the built-in agents-md mod I covered in Claude Code Mods vs Plugins.
If you keep both tools, keep one rules file and make it CLAUDE.md, or symlink one to the other.
Do you need a MiniMax account to try it?
No. On a fresh install, mcode exec refused to run and told me to sign in. That is fair default behavior. But once I added a custom provider with mcode provider add, it ran happily with no MiniMax login at all. The custom provider supports three API formats: anthropic-messages, openai-completions, and openai-responses.
That means you can point MiniMax Code at Claude, at an OpenAI-compatible endpoint, or at a local model server, and compare harnesses with the model held constant. That is the only fair way to compare harnesses anyway.
If you do want MiniMax’s own models, their Token Plan pricing page lists Plus at $22 a month, Max at $55 and Ultra at $132, with 5-hour and weekly quota windows. Claude’s plans that include Claude Code sit at $20, $100 and $200.
Two smaller practical notes from the install. MiniMax Code needs Node 22.19 or newer. It installed in six seconds, pulled 43 packages, and took 67 MB on disk. Claude Code’s npm install pulled a native binary and took 228 MB.
The ten-minute test you can run tonight
Make an empty folder and run git init inside it. Save the mock script above as mock.js and start it with node mock.js 8788. Point your agent of choice at it using the commands above. Ask it to say hi.
Then open the newest req_*.json file. Count the tools. Search for the names of your MCP servers. Search for a sentence from your CLAUDE.md. You will see exactly what your agent carries on every step, in its own words, with nothing hidden behind a dashboard.
Do it once with your normal setup and once with a clean home folder. The difference between those two files is your personal overhead. Don’t be surprised if it turns out bigger than the harness itself.
If you want the background on why rules files swell in the first place, the CLAUDE.md pattern that went viral earlier this year is still the best short read. For how the agent loop reuses that suitcase step after step, the learn-claude-code walkthrough maps it cleanly.
What this tells you about where coding agents are heading
A year ago the race was about the model. Now the harness is the product, and the harness has a weight. MiniMax shipping an open, readable one does something useful for everyone: it gives you a second suitcase to compare against.
My read after this test is simple. MiniMax Code is not better than Claude Code because it is lighter. It is lighter because it does less by default. Claude Code carries more because it can hand off, schedule, and coordinate work that MiniMax Code leaves to you. Which one wins depends on whether you use those extras.
What nobody should do anymore is guess. The requests are right there. Capture one.
Common questions about MiniMax Code vs Claude Code tokens
How many tokens does Claude Code use before my first prompt?
In my bare test with version 2.1.282, about 26,000, with tool definitions making up roughly 70% of that. Real setups with MCP servers, plugins and a CLAUDE.md run higher. Other public tests have measured around 33,000.
Is MiniMax Code cheaper to run than Claude Code?
Its harness overhead was about half of Claude Code’s in my test, roughly 12,600 tokens versus 26,000. The bigger cost driver is still the model you choose, and prompt caching already discounts the repeated overhead on both.
Can MiniMax Code use my Claude Code CLAUDE.md and skills?
Yes. Version 0.5.4 loaded CLAUDE.md and skills from .claude/skills in my test. If both CLAUDE.md and AGENTS.md exist, it used CLAUDE.md and ignored AGENTS.md, so keep a single rules file.
Can I use MiniMax Code without a MiniMax account?
Yes. Add a custom provider with mcode provider add in Anthropic or OpenAI format and it runs without logging in. Without a provider, mcode exec asks you to sign in first.
If you try only one thing from this post, run the mock server against the agent you use every day. You will never look at “context left” the same way again.