Open Tab

In April 2026, Uber ran out of money for AI. Not all of it — just the line budgeted for AI coding tools. Four months into the year, the number was gone.[1] The cause wasn't a failure. It was a success: by March, roughly 84% of Uber's engineers were using Claude Code, and they were using it constantly, because it worked.

Wait — who approved that?

That question — asked by a finance lead staring at an invoice that tripled while everyone was busy being more productive — is the most under-budgeted moment in AI right now. Nobody put it in the rollout plan. Nobody set an alert for it. It doesn't show up on the adoption dashboard, which is all green. It shows up thirty days later, on the bill.

I think of it as the Open Tab. Every autonomous agent you deploy opens one. The agent acts — it spends tokens, makes API calls, and increasingly, moves real money — and the charge accumulates in a place no human is looking until it's large. Most teams pay nothing on the way in and then get a bill at the worst possible time, with no itemization and no name attached to it.

This essay is not an argument against agents. The leverage is real and worth having. It's an argument that the leverage is exactly why the tab grows, that the cost has already started making decisions for companies that weren't watching it, and that there are three specific controls that let you keep the upside without the surprise. Cost here is not the enemy. It's the thing you forgot to instrument.

The dangerous version of this story would be “agents are wasteful.” That's not what the numbers say. The numbers say agents are used, heavily, the moment they're good — and that consumption, not waste, is what blows the budget. Uber's engineers didn't misuse Claude Code. They adopted it faster than the budget assumed anyone would.[1]

The same week, Microsoft began revoking its own internal Claude Code licenses, framing it publicly as “toolchain unification.” The reporting points at a simpler cause: employees vastly preferred it, the token bills ran hot, and the math stopped working.[1] Two of the most sophisticated engineering organizations on earth got surprised by their own success in the same month.

Zoom out and the pattern hardens. Gartner expects more than 40% of agentic AI projects to be cancelled by the end of 2027, citing escalating costs and unclear value as the top reasons.[3] MIT's study of enterprise deployments found that roughly 95% of generative-AI pilots produced no measurable impact on the P&L, despite $30–40 billion invested.[2] Klarna ran the most public version of the round trip: it replaced the workload of some 700 support agents with AI, declared victory, then walked it back when quality fell and started rehiring humans.[4] The cost-cut that ate its own savings.

None of these are stories about bad models. They're stories about good tools meeting an organization that had no meter on them.

When you buy a coffee, three things happen in the same second. You authorize the spend. You see the amount. And you own the charge — it's on your card, in your name. For all of human commerce, those three have been fused into a single act. You can't spend without knowing what and agreeing to it.

An autonomous agent pulls them apart. The authorization happened weeks ago, as a vague instruction (“help the team ship”) or a broadly-scoped mandate. The visibility lags by a full billing cycle — you find out what the agent did when the invoice arrives. And the ownership is genuinely unsettled: when an agent makes a bad call, whose budget, whose fault, whose problem?

You authorize, you see, you own — in the same instant. The agent is the first thing that can spend without doing any of the three.

This is why the surprise feels like a betrayal rather than a line item. The team didn't overspend on purpose. The spending simply happened in the gap the agent opened between acting and accounting. Close that gap and the panic disappears. The Open Tab is the discipline of closing it.

Before you deploy an agent that can spend anything — tokens, API budget, or actual money — you owe it three controls. Each one puts back exactly one of the things the agent pulled apart. Skip any of them and you have not deployed an agent. You have opened a tab.

1. 01.

   The Limit

   A hard, in-path ceiling the agent cannot cross — on tokens and on dollars — enforced before the spend, not reported after. Most teams have logging and alerts, which is not a limit; an alert tells you the money is already gone. The gap is real and current: Stripe's own agent toolkit can gate which operations an agent performs but not how much it can spend, an open issue its engineers have flagged but not closed.[10] And no protocol today enforces a budget ceiling across a fleet of agents. Until it can't spend the next dollar, it can spend every dollar.

2. 02.

   The Meter

   Real-time, per-agent attribution of what was spent and why — visible before the bill, not on it. The hidden costs live exactly where no one looks: load three MCP servers into an agent and their tool definitions alone can consume 143,000 of a 200,000-token window — 72% — before the agent answers a single question.[5] An agent burns 15–30× the tokens of a chatbot for the same output, because every step re-reads the whole conversation. A meter makes that legible while you can still act on it.

3. 03.

   The Owner

   A named holder of the liability, assigned before the agent acts — not discovered in a dispute. Right now, liability for an agent's spending “follows evidence”: whoever can produce the mandate, the agent ID, and the audit trail decides where the cost lands.[12] American Express is so far the only card network to simply pledge it will cover erroneous purchases by registered agents — an outlier precisely because everyone else has left the question open.[11] If you can't name the owner on a whiteboard, the default owner is you, later, by surprise.

Here's the part the cost-panic narratives get wrong. The answer to a runaway tab is not “use the agent less.” That throws away the leverage you deployed it for — and it's how you end up in Gartner's 40% that gets cancelled. The answer is to instrument the spend so the same work costs a fraction of what it did.

The levers are well-documented and large:

• Prompt caching. Reusing the stable part of a prompt instead of re-sending it cuts cost by up to ~90% and latency by ~85% on long contexts.[9] For agents that re-read the same instructions every step, this is the single highest-leverage change.
• Model routing. Send the easy 80% of calls to a cheap model and escalate only the hard ones, and you cut 45–85% of cost while holding roughly the same quality.[7]
• Code execution over tool sprawl. Letting the agent write code that calls tools — rather than loading every tool definition into context — has produced a 98.7% token reduction on tool-heavy agents.[6] The 72% context tax from the Meter above is not a law of nature; it's a default you can turn off.
• The unit metric. Stop watching total spend and start watching cost per task. Falling per-token prices hide a rising tab because tokens-per-task climbs faster — CloudZero calls it AI's “false-efficiency curve.”[8] Cost per completed task is the number that tells you the truth.

Notice what these have in common. None of them ask you to want the benefit less. They ask you to see the cost clearly enough to remove the waste hiding inside it. That is the Meter and the Limit doing their job.

Make it concrete. You ask an agent to add rate limiting to your API. Same feature, two ways to start — and the tab between them differs by an order of magnitude.

The open-tab way. You type “add rate limiting, look around the repo and figure out where it goes.” The agent greps, opens eighteen files to learn the structure, carries four MCP servers' worth of tool definitions it never calls, and re-reads the whole conversation on every step. Vague prompts like “improve this codebase” trigger exactly this broad scanning.[13] A 5,000-token CLAUDE.md is billed on every single turn.[14] The model is Opus, which runs about 5× the per-token cost of Sonnet.[14] Nothing here is a mistake. It's just unmetered.

The instrumented way. You hand it a forty-line markdown brief that names the three files and the pattern to copy. You point it at exact paths instead of “look around.”[13] You feed the failing log as a pre-filtered digest — a hook that greps for errors turns a 10,000-line file from tens of thousands of tokens into a few hundred.[13] You run Sonnet. You keep CLAUDE.md under 200 lines and move the workflow detail into a skill that loads only when it's used.[13] And when the agent has to answer at length, you have it return IDs and positions, not prose — output tokens cost 5× input, and mapping them back in code cut one team's output bill by ~60%.[15] The same feature ships.

Hand the agent a digest, not a drawer.

That's the pattern under all of it. A focused markdown brief, a single PDF, three named files — anything you pre-chew — costs a fraction of what it costs to let the agent open the whole folder and read its way to understanding. The most expensive token is the one spent re-discovering what you already knew.

And the tab moves even when your inputs don't. In early 2026 Anthropic quietly cut the prompt-cache lifetime from sixty minutes to five, which raised effective costs 30–60% for some production workloads; a new model tokenizer generated up to 35% more tokens for the same text.[15] You catch neither unless something is watching. That is the entire argument for a Meter.

Across a team it compounds. Anthropic's own enterprise numbers put Claude Code at roughly $13 per developer per active day, $150–250 a month — the disciplined baseline.[13] Spin up agent teams that each carry their own context window and you're at about 7× the tokens.[13] The difference between a $200 month and a $2,000 one is rarely the model. It's whether anyone instrumented the inputs.

The directive is short enough to put on a single slide. You don't ship a spending agent without all three:

• Set a Limit it cannot cross. A hard ceiling on tokens and dollars, enforced in the request path, plus tiered alerts at 50%, 80%, and 100%. One founder watched a single runaway loop spend more than a week of normal usage in one night.[15] An alert is not a limit — but no alert at all is how you find out from the invoice.
• Put a Meter on it before you turn it on. Cost per task, per agent, in something close to real time. If you find out what the agent spent from the monthly invoice, the meter is the invoice, and the invoice is thirty days too late.
• Name the Owner out loud. Decide, before deployment, whose budget the agent draws on and who holds the liability when it's wrong. Write it down. “We'll figure it out” means the owner is whoever is unlucky enough to be in the room when the dispute lands.
• Then spend the savings on more agents. This is the point. The discipline isn't a brake — it's what lets you press the accelerator without driving into a wall. Teams that can see and bound their tab can deploy more agents, not fewer, because they're no longer one surprise invoice away from a freeze.

The 40% of agentic projects that get cancelled won't die because the agents didn't work. They'll die because the tab came due in a room where no one could explain it. The teams that survive will be the ones whose agents have a limit, a meter, and a name on the bill — and who therefore get to keep going.

An agent that can spend is a credit line you handed to software. You can run it deliberately, with a limit, a meter, and a name — or you can find out what's on it when it's due. Open the tab on purpose, or it opens itself.