The Token Tax

Talking to your agent in Turkish makes it about 1.8x dumber. Same question, same answer, just nearly double the tokens, and every one of those extra tokens is attention the model spends on nothing.

That's the part the "is this even worth optimizing" debates miss: the token count isn't your bill, it's how much of the model's head is left for the actual problem. So instead of guessing, I measured what actually moves it, end to end, against Claude Opus 4.8.

The short version:

• Turkish vs English — 1.8x, both to read it and to write it
• ALL CAPS vs lowercase — 2.05x, same words, just shouted
• Pretty vs minified JSON — 1.64x, identical data, more whitespace
• Base64 vs prose — 3.7x, the worst thing you can paste, almost one token per character
• A single family emoji (👨‍👩‍👧‍👦) — 14 tokens for one glyph
• Saying "please" — 1.1x, basically free, and it doesn't change the answer

More tokens isn't just a bigger bill

The bill is the boring cost. You pay per token in and out, fine. But three things happen at once:

• You hit the context window sooner. Fewer turns, smaller documents, shorter memory before it starts truncating.
• It's slower. Output is generated one token at a time, so 1.8x the tokens is roughly 1.8x the wait.
• The model gets dumber. This is the one nobody prices in.

That last one is the real point. Attention is finite and shared across the whole context. Every junk token, a shouty heading, a 36-character UUID, a bloated JSON blob, is a low-information token that the model still has to look at. So the signal you care about becomes a smaller slice of the whole, "lost in the middle" gets worse as the context grows, and answer quality drifts down.

So token efficiency isn't a billing optimization, it's a quality one. A leaner prompt is a smarter model. More of its attention lands on what actually matters.

How I measured it

The hard part is getting a clean number. A normal claude -p call drags ~24k tokens of scaffolding along (tools, system prompt, project files, MCP config) before your prompt even shows up, so any small effect just drowns.

So I stripped the harness down to almost nothing. Baseline scaffolding drops from 24,430 tokens to 181:

claude -p "$PROMPT" --output-format json \
  --system-prompt "You are a helpful assistant." \
  --tools "" --setting-sources "" \
  --strict-mcp-config --mcp-config '{"mcpServers":{}}' \
  --exclude-dynamic-system-prompt-sections

One more trap: the headline "input tokens" field lies. The real number is the sum of three fields (input + cache_read + cache_create), so that's what I count.

Why I trust the numbers:

• Deterministic — same prompt twice gives the identical count, delta 0.
• Exact — one "elephant" is +3 tokens, ten is +31.
• Contained — a 181-token floor, no CLAUDE.md, MCP, or env leaking in.

Language is the biggest lever

Same sentence, eleven languages, identical meaning. The spread runs 1.0x to 2.4x.

The same sentence, four ways:

EN · 28 tok  Artificial intelligence is changing how people work, learn, and communicate around the world.
ZH · 28 tok  人工智能正在改变世界各地人们的工作、学习和交流方式。
TR · 51 tok  Yapay zeka, insanların dünya genelinde çalışma, öğrenme ve iletişim kurma biçimini değiştiriyor.
TH · 68 tok  ปัญญาประดิษฐ์กำลังเปลี่ยนวิธีที่ผู้คนทั่วโลกทำงาน เรียนรู้ และสื่อสาร

Chinese ties English at 1.00x, which is the surprise. It's the worst per character, but each Han glyph is a whole word, so the sentence ends up tiny. Density wins. Thai and Hindi are the losers (2.4x and 2.2x): barely-merged scripts where almost every character is its own token, and still many characters per word.

Turkish, since it's mine, I dug into. It's 1.84x to read the same paragraph (210 vs 114 tokens over an identical 415 characters) and 1.83x to write the same answer (287 vs 157, three-sample mean). The tax is symmetric. You pay both directions: it costs more to feed Turkish in, and more for the model to produce it.

Formatting: caps, whitespace, junk

How you encode the same content matters as much as the content. Cost here is per character, against normal English prose.

English prose is 0.255 tokens/char. Base64 is 0.93, basically one token per character, the worst thing you can hand a model. IDs and hashes sit around 2.5x. A wall of UUIDs or a base64 blob pasted "just in case" is the most expensive thing in your context, and usually the least useful.

Two more, same content, different shell:

• ALL CAPS is 2.05x lowercase. Same words, just shouted. Capitals fragment into more tokens.
• Pretty-printed JSON is 1.64x minified. Identical data, you're just paying for whitespace. Minify anything the model doesn't need to read by eye.

The one free lunch

Saying "please" is 1.1x. Effectively nothing, and it doesn't change the answer. So if being polite to the machine makes you feel better, go ahead, it's the cheapest thing here. Relax.

What to actually do

Nothing exotic, just stop paying the tax you don't have to:

• Write to the model in English if you comfortably can, especially for long context.
• Lowercase and minify anything it only needs to parse, not admire.
• Keep base64, UUIDs, and raw hashes out of context unless the model genuinely needs them. Link or reference instead of pasting.
• Don't sweat "please". Spend the worry on the blob, not the manners.

The token economy is English-first, lowercase, and minified. Step away from any of those and you pay, anywhere from 1.1x to 3.7x. And the bill was never the expensive part.