I Burn 18 Billion Tokens a Month. It Costs $1,200.

TL;DR: My average token burn over the past few months is ~18 billion tokens per month. Priced at Claude retail — cache or no cache — that's $20,000 to $200,000 of monthly cognition. My actual bill is about $1,200. The gap isn't a discount; it's architecture. I own my data, my workflow logic, and — through my routing engine, Mercury Flux — the choice of model on every single call. Everyone else optimizes how much AI they use. The real leverage is what you pay for the same output. Rent the models. Own everything else.

I am James, CEO of Mercury Technology Solution, writing from Hong Kong.

Yesterday I finally did the accounting I'd been avoiding: pulled months of logs and measured my token metabolism. The number came back at roughly 18 billion tokens a month. Sustained.

Two reactions, in order:

1. That explains a lot. The book chapters, the blog posts, the audit packs, the agent fleet, the 1,290-post archive pipeline, agentic ERP and multiple projects — none of it is magic. It's throughput. Cognition at industrial volume.
2. Wait — what would this cost a normal person?

What 18 Billion Tokens Actually Is

18 billion tokens a month is 600 million a day. It's roughly 7,000 tokens every second, around the clock, no sleep.

A heavy knowledge worker poking at a chat subscription — say 200 detailed conversations a month — burns a few million tokens. Call it 10 million on an extreme month. My metabolism runs three orders of magnitude above that.

This is the part people miss about AI productivity. The difference between "I use AI" and "I operate with AI" isn't prompt skill. It's volume. Token throughput is the closest proxy we have for cognitive surface area — how much reading, drafting, reviewing, cross-checking, and iterating a person-plus-machine system can do per day. Most people are rate-limited by their subscription tier and never notice the ceiling, because they've never leaned on it.

The Retail Illusion

Price the same burn at retail. Using Claude as the benchmark — and Claude is the right benchmark, because for serious agentic work it's what teams actually reach for — blended rates run roughly $1 to $10 per million tokens depending on tier, context, and how much the cache saves you.

18 billion tokens at those rates: $18,000 to $180,000 a month. Call it the $20K–$200K metabolism.

Here's the uncomfortable truth: almost no individual, and almost no enterprise department, approves that number. So nobody operates at that metabolism. They cap their cognition at what the budget allows, then wonder why their AI output feels like everyone else's — because it is. The subscription tier is a speed limit on your thinking.

The real reason "AI hasn't made everyone 10x productive" is simpler than the discourse admits: 10x productivity is a token-volume phenomenon, and almost nobody can afford the tokens at retail.

The Actual Bill

My real spend: about $1,200 a month.

Divide it out. That's roughly seven cents per million tokens, blended across everything — drafting, coding, research, translation, the swarms. Against the cheapest retail scenario, the same cognition costs 15x more. Against the realistic agentic scenario — long contexts, frontier model, cache misses — it's 100x and up.

Under 6% of the cheapest Claude scenario. Under 1% of the worst.

And no, I don't run worse models everywhere. The outputs you've read — the book chapters, the audit reports, this post — are not seven-cent quality. The trick is not "cheap model." The trick is paying frontier prices only where frontier quality actually changes the outcome.

Rent the Models, Own Everything Else

The savings aren't a hack. They're the consequence of three ownership decisions made early, on principle:

1. Own the data. Every memory file, daily note, entity card, session transcript, and decision log lives in files on machines I control, in formats I can read with cat. Nothing of consequence sits inside a vendor's database where the retrieval fee compounds forever. The vendor holds the weights; I hold the context. Context is the asset that appreciates.

2. Own the workflow logic. The prompts, the agent harnesses, the quality gates, the pipelines — local code, version-controlled, inspectable, refactorable. When a workflow produces value, the value lands in my repo, not in someone else's template library. Vendors can rent me intelligence. They cannot rent me my own judgment, encoded.

3. Own the model choice. This is the one that does the economic damage. Between me and every model sits my routing engine — Mercury Flux. Every call gets classified by task and routed to the model that wins on price-quality for that class, with fallback chains when a provider chokes.

The principle is the pilot, not consumer: operators don't buy brands. Operators dispatch capabilities.

The Routing Moat

Everyone treats the AI bill as Cost = Tokens × Price, then optimizes Tokens — shorter prompts, fewer calls, less AI. Fine. But that's optimizing your metabolism downward. Capping cognition to save money is a poverty strategy.

The other term is Price — and price is not a constant. It's a function of routing.

Cost of Cognition = Tokens × Blended Price, where Blended Price = Σ (share of tokens by task class × best price for that class).

In my stack, the overwhelming majority of tokens — retrieval, classification, summarization, translation, first-draft generation — route to models that cost a fraction of frontier rates. The frontier model handles the last mile: the final cut of a chapter, the architecture decision, the client-facing judgment. The expensive intelligence is special forces, deployed at the point of maximum leverage — not the standing army occupying every street. No general sends special forces to patrol every block. No operator should send a frontier model to summarize a webpage.

The Routing Moat: whoever controls model selection controls the cost of identical output. Model quality is the vendor's moat. Selection is yours.

Note what happens as prices fall — and they will. The frontier-to-mid-tier gap doesn't close; it's a spread. Routing captures the spread in any price regime. Today's frontier becomes tomorrow's mid-tier, and the router re-indexes automatically. The moat doesn't erode with deflation. It re-indexes.

Why Swarms Change Everything

The second-order effect nobody prices in: cost structure determines org structure.

At retail prices, a 15-agent council — one drafter, four critics, a fact-checker, a style enforcer, reviewing in parallel — is a conference-talk demo. Nobody staffs councils on every deliverable at $10 per million tokens. At seven cents blended, a council is a line item. My swarm lives on a Mac Studio. It hums. It doesn't invoice me.

Cheap cognition makes division of labor affordable. You stop building "a chatbot" and start building an org chart of agents — drafters, reviewers, auditors, librarians — with routing as the HR department. That's the actual mechanism behind the output volume. Not genius prompts. Staffing.

The Enterprise Version

If you're a CAIO or CTO, run the same audit on your organization. Your teams are burning tokens somewhere; the only question is whether it flows through your routing layer or through whatever button is nearest.

Two notes from my consulting life:

• Agentic workflows die at retail prices. The workflows that actually move numbers — continuous GEO audits across ChatGPT, Perplexity, and Gemini; citation monitoring; entity tracking; always-on lead qualification across the AI-to-human handoff gap — are token furnaces by design. At retail, they're born dead, and everyone concludes "AI is expensive." Routed, they're cron jobs.
• Vendor lock-in is renting your own workflow back. Every year without a routing layer, the upgrade path is pay more, move less. SaaS taught enterprises this lesson once. AI is teaching it again, with compounding interest.

Stop buying intelligence retail. Start scheduling it like compute — price-discovered per task, swappable per call, owned at the layer that matters.

What You Do Monday

1. Measure your metabolism. Pull real token counts across all tools for 30 days. You cannot manage a number you've never seen. Most teams are off by 10x in one direction or the other.
2. Move your state to files you own. Memory, decisions, workflow logic — out of vendor silos, into your repo. A weekend of work. It compounds forever.
3. Put a router between you and every model. It doesn't have to be Flux — build the thin version. Task classification, model mapping, fallback chains, cost logging. Even a crude router cuts the bill 5–10x in month one.
4. Reinvest the spread. The savings aren't the point. The point is what a $20K metabolism at $1.2K cost buys: the council, the swarm, the volume, the speed. The gap between you and everyone else stops being talent and becomes throughput.

The most expensive AI strategy in 2026 isn't picking the wrong model. It's paying frontier prices for every token because you never built the layer that chooses.

Rent the models. Own the routing. Keep the difference — then spend the difference on more cognition.

Mercury Technology Solution: Accelerate Digitality.