The token tax is real. Here's the math that made me self-host.

Half my job lately is talking clients out of using more AI. Not because AI is bad. Because the pricing math right now is a slow leak that turns into a flood the moment you run anything autonomous. I built the self-hosted stack I run today because I ran those numbers and didn't like where they pointed. This is that story.

The "cheap Uber rides" problem

Silicon Valley has done this before. For a decade, venture capital underwrote below-cost pricing on rides, deliveries, and streaming to capture market share. You got Uber rides that cost pennies on the dollar to actually run. Eventually the subsidies ended, prices corrected, and anyone who'd built a business model around those artificially cheap unit economics had to scramble.

AI is running the same play. The flat-rate, cheap frontier model access you're using today is not priced at true compute cost. And the people funding that gap are asking serious questions about when they get paid back.

Sequoia put a number on it. David Cahn's "$600B question" estimates that the AI industry needs roughly $600B in annual revenue just to break even on the current infrastructure buildout. GPU spend is only half the picture. Energy, buildings, and cooling double it. Add a healthy gross margin for the provider on top, and you get a revenue requirement that the industry isn't anywhere close to hitting. Prices are going up. That's not a prediction, it's arithmetic.

The repricing has already started. Most people missed it.

This isn't future tense. GitHub Copilot already repriced its premium models at 3.6-6x the base rate. Providers are pivoting from flat subscriptions to usage-based, per-token billing. That's a direct transfer of compute risk from vendor to customer. And it hits hardest on exactly the use case everyone is excited about right now: autonomous agents.

A single chatbot call is cheap. You send a message, get a response, done. Maybe a few hundred tokens. But an "agentic" workflow, where an AI reasons through a task, calls tools, re-reads its own context, loops back, and tries again, is a completely different animal. Research from Gartner puts the gap at 5-30x the tokens of a standard chat call. That's not a typo. A task that costs next to nothing in a chat window can cost dollars per run when you let an agent "just figure it out."

At low volume, fine. At production scale, across every process you've handed to AI, that's a line item that will show up on your P&L and keep growing.

What an agentic token bill actually looks like

Here's a rough breakdown of token consumption by interaction type at current pricing. These aren't hypotheticals. They're what I see in production logs across different kinds of automation work.

Now multiply the agentic loop row by how many processes you want to automate. Multiply again by how many times each process runs per day. The math gets uncomfortable fast, and that's at today's subsidized prices.

Why "AI for everything" fails the business case

The appeal of agentic automation is real. You describe what you want in plain language, the agent figures it out, and things happen. It feels like progress. It produces polished output. But "AI for everything" consistently fails the business case for one reason: AI tokens have a cost, deterministic logic doesn't.

Think about the actual decision structure of most business processes. Someone submits a form. You validate the fields. You check if a record already exists. You route based on type. You write to a database. You send a notification. Almost none of those steps require probabilistic reasoning. They're rules. Hard, testable, predictable rules.

Every time you use an LLM to "reason through" a rule that could just be an if-statement, you pay a token tax on something that should cost zero. You also introduce hallucination risk into a path that would otherwise be completely deterministic and testable.

I rebuilt a client's intake pipeline that was using AI across the whole flow. Routing, field extraction, CRM writes, notifications, the works. I replaced the deterministic parts with deterministic code. One constrained AI call handled only the genuine edge cases: unstructured text that actually needed semantic understanding. The result was -70% manual data entry and a token spend that dropped to a fraction of what they were burning. The pipeline runs cleaner now and costs less.

How I actually build it: the deterministic-first method

The question I ask before every automation decision is this: can a rule decide this? If yes, hard-code it. Zero tokens, zero hallucinations, fully testable, runs forever for free.

If not, and only then, I use the cheapest capable model for the task. Semantic cache first. Route simple classification to a small model. Reserve frontier models for genuine multi-step reasoning. Human-in-the-loop gate on anything touching money or client records.

The self-hosted stack that makes this possible

Running deterministic-first automation at scale requires infrastructure you control. If your orchestration layer is a SaaS platform, you're paying per-execution fees on top of your token spend. If your data moves through third-party APIs, you're adding latency, egress costs, and a new failure point every hop.

I run everything on self-hosted n8n with Docker Compose and Traefik for routing. Data lives in Supabase (Postgres) and Qdrant handles vector search for semantic caching. When a query hits the cache, no token is spent. When a query needs a model call, it gets routed to the cheapest capable option.

The key insight from Sequoia's analysis is this: GPU compute is a commodity. Providers who own nothing but rented GPUs have no pricing moat. Every new hardware generation makes the prior generation cheaper, which means sunk capex erodes fast. The incentive to raise prices on the software layer is enormous. Owning your own orchestration and keeping AI at the edges of your workflows is the hedge against that.

What "boring on purpose" actually means

I call my automation stack "boring on purpose." Deterministic is boring. Rules are boring. If-statements are boring. They're also reliable, cheap, testable, and completely immune to pricing shocks. Boring automation doesn't hallucinate. It doesn't wake you up at 3am because a vendor raised prices. It runs.

The builds I'm proudest of are the ones that look underwhelming on a demo. A billing sync that moved zero invoices to "missed" because it's just deterministic rules running on a schedule. A lead intake that cut manual data entry by 70% because it routes deterministically and uses one cheap, capped AI call only when the input is genuinely unstructured. A lead scoring system that lifted conversion by +30% because the routing is tight and the AI call is constrained, not because we gave AI free rein over the whole pipeline.

None of these are flashy. All of them are in production. None of them will break when a vendor raises prices, because the parts that are expensive to run are already replaced by the parts that are free to run.

What to do before the subsidy ends

You don't need to rip out everything you've built with AI. You need to audit what you've actually handed to AI versus what could be a rule.

• Audit by task, not by total bill. Aggregate spending hides which agents are burning budget without producing value. Log every AI call by specific task and look at cost-per-outcome.
• Identify deterministic candidates. If a process can be drawn as a flowchart, hard-code it. Don't pay an LLM to reason through static logic on every execution.
• Add semantic caching before you add more AI. A vector cache that serves stored answers for similar queries cuts spend without changing the workflow. Use namespacing to prevent cross-tenant data leaks.
• Move orchestration off SaaS. Self-hosted n8n eliminates per-task execution fees. One host, one bill, your data stays on your infrastructure.
• Put a human gate on anything irreversible. Agents make mistakes. The cost of a human approval step is much lower than the cost of an agent writing bad data to a client record at scale.

The businesses that come out ahead on the other side of this pricing shift are the ones that built cost-resilient automation now, not the ones that bet everything on cheap tokens staying cheap.

I've shipped $800K+ in hard-dollar savings across 50+ automations by treating AI as a scalpel, not a hammer. The deterministic work runs free. The AI work is capped, gated, and audited. That's the architecture that holds when prices correct.