The envelope tax

There is a quiet, expensive, environmentally costly thing happening every time anyone uses AI today. It costs the industry more than $400 million a year in direct cloud, network, and compute fees. It adds to data-center buildout, grid pressure, and water usage in regions already short of all three. And it prices billions of people out of AI for reasons that have nothing to do with the model and everything to do with the wire that carries it.

All of it traces back to a single architecture decision made in 2022, when AI was new and nobody was watching the bill. The decision is still in force. The bill is real. Almost nobody is looking at it.

Call it the envelope tax: the cost of stuffing the model's native output into a stack of envelopes that the only reader at the other end, usually another machine, immediately tears open and throws away.

What actually happens when you talk to an AI

Watch a ChatGPT response stream into your browser. Characters appear one at a time, as if the model is typing. The animation is satisfying. It is also a lie about what the model is doing.

The model does not emit characters. It emits tokens, which are integer IDs drawn from a fixed vocabulary of around 100,000 entries. A token might stand for a whole word like "the," a fragment like "ography," or a single character. Each token is a number, roughly 17 bits of it. Internally, the model produces and consumes those numbers natively. The text you see is a costume the system puts on at the very end.

Here is the costume change, step by step. The model emits a token, a number. A server-side tokenizer converts that number into a piece of text. The text is wrapped in a JSON envelope (the standard web packaging format). The JSON is shipped over the network. Your browser unwraps it, extracts the text, and paints it on screen, where the character-by-character animation finally happens, after the text has already arrived in bulk. The streaming visual is decorative. The waste is upstream.

The model emitted one 17-bit number. Your browser received something on the order of 60 to 190 bytes for that single token, depending on packaging overhead. That is the envelope tax in miniature, paid on every token of every response.

Text is currently doing three jobs in the AI stack. It is the format the model conceptually consumes after tokenizing. It is the format that ships over the wire. And it is the format humans read on screen. Text is good at exactly one of those jobs, the last one. The other two are accidents of an API designed back when humans were the only callers. The model's natural format is token IDs. The wire's natural format is efficient binary. Forcing both into text is a translation step that exists for nobody.

The bill

Across the industry, roughly 5 billion conversational AI requests per day (about one-third the volume of Google search, per public estimates from OpenAI, Anthropic, and Google) run through this text-and-JSON architecture. The visible cost:

The dollar figure is the part that makes a CFO care. The part that makes a grid operator care sits underneath it and lands on no invoice. Every gigabyte of envelope that does not need to ship is a gigabyte of network capacity that does not need to exist. Every GPU-second wasted on a doomed prompt is a GPU-second the next data center does not have to add, with the cooling water and the grid interconnection that come with it. This is the same bill, viewed from a distance, that the wealth-transfer piece tracks at the scale of megawatts and water tables: an invisible cost that no single team owns, that shows up years later, and that lands on people who never made the decision.

The market the architecture quietly excludes

The flawed architecture is not just expensive. It actively prices billions of people out of AI, and this is a global story rather than a developing-world one. Half the world is on mobile-only metered connections: much of the Middle East, Southeast Asia, India, Latin America, and the rural fringes of Europe and North America. Mobile-only does not mean poor. It means the wire matters.

At the heavy-agent baseline, a single AI request moves roughly 4 megabytes of JSON back and forth before the user sees an answer, because a real request makes about eight round-trips (model emit, agent handoff, tool call, tool result, sub-agent dispatch, synthesis, response, render), and every one repeats the same conversion ritual. On a metered connection, that 4 MB is what shows up on the bill. At legacy satellite rates it is catastrophic: a single agentic request can bill $20 to $60 just for envelopes, against under four cents on a token-native wire. That is the difference between "AI works on this connection" and "AI is impossible on this connection."

The time cost is just as decisive:

Below the phones sits an entire category of devices that physically cannot fit a JSON AI conversation in their network budget. Not "too expensive," impossible. A LoRaWAN sensor (the kind on a farm soil monitor or a utility meter) has a payload window of 11 to 242 bytes per transmission and may send only a few times a day to preserve battery; a 4 MB request is roughly 20,000 times too big to even attempt, while a binary token response fits in one or two packets. Sigfox endpoints get 12 bytes per message. NB-IoT meters run on a few hundred kilobytes per day. None of them can run AI today. All of them could on a token-native wire. The industry has written off smart agriculture, wildlife conservation collars, cold-chain anomaly alerts, disaster-response triage, and remote-infrastructure monitoring, not because the model could not help, but because the envelope would not fit.

Where it compounds: agents calling agents

The waste was a rounding error when AI meant one human typing into a chat box. It is structural now that the largest consumers of AI are pipelines and agents (programs that call the model in a loop, and increasingly call other agents). When two agents talk, today's stack has the first one's model emit token IDs, convert them to text, wrap them in JSON, ship them, and then has the second one's server convert the text right back into token IDs for its own model. Every step in the middle exists for an audience of zero. No human reads the intermediate text. Both ends speak numbers natively.

Drawing the layers correctly does not just shrink that traffic, it makes whole categories of work disappear. Take the most common operation in agent systems: detecting that the model wants to call a tool. The model marks a tool call with a single special token, a single number. In today's text stack, an orchestrator has to detokenize the stream, scan the resulting text with pattern-matching, and buffer across frames to catch it, because what arrived was text. On a token-native wire it is one number compared against another. Measured head to head, that comparison runs at about 1.6 billion tokens per second on one CPU core, against about 16 million for the detokenize-and-scan path, a hundredfold difference. When an operation gets that cheap, you stop building infrastructure around it. The detection workers, queues, and caches that existed only because the question was expensive simply stop being necessary.

The fix is small

The fix is not bigger data centers, not 6G, not "compress harder," and not any of the blockchain-flavored "decentralization" pitches. It is this: stop doing every conversion in the cloud, and move a tiny amount of trivial work to the edge that was going to handle bytes anyway.

A client that speaks the model's native token format does three small things the cloud no longer has to. It holds a token dictionary locally (a few hundred kilobytes on a phone, a viable subset on a microcontroller), so numbers can flow over the wire without being converted at every hop. It runs a basic safety and format check before shipping a prompt, catching the roughly 10% of doomed prompts that the cloud would otherwise burn a full GPU pass to reject. And it speaks a small binary frame instead of JSON: same content, no envelope. None of this requires new model capability. None of it changes what the model does.

The payoff: up to 1,700x less data per round-trip, wall-clock that collapses from minutes to under a second on slow links, cloud bills lighter by $300-700M a year industry-wide, GPU compute on doomed prompts recovered, eased grid and cooling pressure, and entire device categories online for the first time. An open protocol called Codec (codecai.net) is the structural change: six client libraries (TypeScript, Python, Rust, Java, .NET, and a C library small enough for microcontrollers) that plug into existing AI servers such as sglang, vLLM, and llama.cpp with no rewrite. Same model. Same prompts. Same answers. Different transport, different defaults, different economics, different addressable market.

How this ties in

Two of the larger arguments on this site are the same shape as this one, scaled up.

The first is about resources. The wealth-transfer thesis is, at bottom, an accounting of costs the AI buildout pushes onto people who never agreed to them: ratepayers, neighbors, taxpayers, water tables. The envelope tax is a clean, measurable instance of exactly that pattern, sitting inside the protocol itself. Bytes that do not ship are grid capacity, cooling water, and GPU compute that never has to be built. It is the cheapest externality on the whole list to eliminate, because no permit, no substation, and no new generation is involved. It is a writing decision about where the conversion happens.

The second is about where the work lives. The case that the cloud lock-in is eroding turns on AI inference moving from rented cloud compute toward hardware the user already owns. The Codec fix is the same move in miniature: take the trivial conversion and safety work that the cloud currently meters on every request, and put it back on the edge device that was always going to render the bytes anyway. Less rent extracted per request, more capability resident on the client. The protocol is not the dramatic version of that shift, but it points in the same direction, and it is available now.

We cannot make models smaller, GPUs cheaper, or data centers green overnight. We can stop shipping envelopes the AI never reads. The architecture is the bottleneck, and it is the cheapest part of the stack to fix.