Why Microsoft and Uber are pulling the plug on AI agents. The spreadsheet finally caught up with the hype. Here is why the autonomous digita...
 |
| Why Microsoft and Uber are pulling the plug on AI agents. |
In late 2025, Microsoft gave its internal engineering teams access to Claude Code, one of the most capable AI coding assistants available. It was deeply integrated into their workflows, and developers naturally loved it. Then, just months later in mid-2026, Microsoft began pulling those licenses back, deliberately steering teams toward their own cheaper, internal tools like GitHub Copilot CLI. Over at Uber, the situation was even more extreme. In April 2026, Uber's CTO admitted the company had burned through its entire 2026 budget for AI coding tools in just four months. Adoption had skyrocketed to 84% of engineers. Usage turned into a company-wide leaderboard contest, and a single engineering leader blew through $1,200 of tokens in a solitary two-hour demo. The AI didn't stop working. It just became wildly, unsustainably expensive.
When I saw the news about Uber and Microsoft, it clicked perfectly with the friction I've experienced firsthand while building agentic systems. We are hitting a harsh ceiling where the raw compute cost of an autonomous digital worker is rapidly eclipsing the salary of the human it was supposed to replace. Let's break down exactly why this is happening at a system level, and more importantly, how we can fix it using a discipline that is about to become mandatory: Containment Engineering.
Dropped Wrench
To understand the sudden panic in Big Tech, you have to separate a simple chat prompt from an autonomous agent. When you ask a standard large language model a question, the meter clicks exactly once. It is a single, neat exchange. You ask, it answers, the transaction is complete. An agent is a completely different piece of architecture. You don't ask it a question. You give it an open-ended goal. If you tell an AI agent to fix a bug in a codebase, it reads the files, drafts a plan, writes an edit, runs the tests, and evaluates its own output. If the test fails, the loop restarts. It rethinks, rewrites, and tests again. Every single step costs money.
In real-world software engineering, this is a massive financial vulnerability. The SWE-bench is a standard industry test built from real software bugs pulled from actual production code. The best AI agents right now solve less than 50% of these tests. That means for more than half the bugs, the agent tries, fails, tries again, fails again, and eventually just gives up. Imagine hiring a plumber who charges his full hourly rate every time he drops his wrench, bills you for every trip out to his van, and then leaves your house with the pipe still leaking. At an enterprise scale, a failed agent task is exactly that. You are paying full price for the dropped wrench. The token usage for an agent doesn't just double compared to a chat window. It runs 5 to 30 times higher on average. In complex debugging scenarios, a runaway agent can spike past 1,000 times the cost of a standard prompt.
The Scaling Mismatch
The fundamental architectural issue is that human economics and AI economics operate on completely different curves. When a junior developer gets better at their job, their output increases. Their salary, however, stays relatively flat during that immediate growth period. They simply get faster and more efficient at solving problems. When an AI agent needs to solve a complex problem, it requires exponentially more reasoning steps, retries, and context window utilisation. The token bill skyrockets. The harder the problem, the more the cost curves upward.
Even though hardware is constantly improving, the software demands outpace the savings. Microsoft's new Maia 200 chips, running in data centres right now, produce significantly better tokens per dollar than older hardware. But every bit of that infrastructure savings is immediately eaten up by the massive agent workloads stacked on top of it. You make the tokens cheaper, and the agents simply demand exponentially more of them.
Containment Engineering
The dream of turning an AI agent loose on an entire enterprise codebase and walking away is dead. The math simply does not support it. But this doesn't mean agents are useless. It just means our architecture needs to aggressively evolve. If you are building AI applications today, your primary job is no longer just prompt engineering. Your job is Containment Engineering. While recently building an inventory management system utilising Next.js 16, TypeScript, and Azure OpenAI, my biggest concern wasn't latency or model hallucinations. It was the very real fear of an autonomous agent getting stuck in a reasoning loop and draining the available cloud credits overnight. Just a few months ago, I was running a genomic data processing job on the Modal platform, scoring thousands of ClinVar reference sequences.
The task hit a hard execution timeout after exactly two hours. That was a raw compute timeout, but it got me thinking. If that had been a recursive AI agent paying per token instead of a standard compute instance paying per second, that single runaway loop would have cost a fortune. Containment engineering is the practice of building hard boundaries, state limits, and financial tripwires around your AI models. It ensures that the machine creates provable value before it runs up a bill. Here is how you can practically implement this in your stack right now.
1. Routing Beats Brute Force
The most common mistake developers make is pointing every single API request to a flagship model like GPT-5 or Claude 4.5 Opus. That is the definition of brute force, and it is a fantastic way to burn your runway. Instead, you need to build a routing layer at the very front of your stack. A router is a lightweight, incredibly cheap model that evaluates the incoming task and decides which LLM is actually qualified to handle it. If a task is simple data extraction or basic formatting, the router sends it to an open-source 8B parameter model or a highly optimised mini-model. If the task requires deep logical reasoning, it escalates to the expensive flagship model. This single architectural shift can drop your API spend by up to 80% without any noticeable degradation in application quality.
2. Hard Loop Caps and Budget Tripwires
You must never let an agent run an unbounded retry loop. If your agent is allowed to write code, test it, and retry on failure, you must hardcode a strict retry limit. But a simple retry integer count isn't enough because context windows grow with every single retry. The third attempt costs significantly more than the first attempt because the agent is now carrying the full memory of the first two failures in its prompt. You need to implement a budget tripwire. Before the agent executes the next step in its recursive loop, a middleware function should calculate the estimated token cost of the incoming request. If the cumulative cost of the session exceeds a strict predefined threshold, the process is immediately killed and flagged for a human developer to review.
3. Context Pruning
When an agent fails a task and retries, it typically appends the raw error log to its previous prompt and tries again. This is where the exponential cost curve originates. To fix this, implement Context Pruning. Instead of passing the entire verbose history of the failed interaction back to the flagship model, use your cheaper routing model to summarise the failure state. Pass the giant error log to an inexpensive model and command it: "Extract the exact technical reason for this failure in two short sentences." Then, pass only those two sentences back to the main agent for its next attempt. You are actively pruning the context window, forcing the token count to scale linearly instead of exponentially.
4. The Verification Specialist
This brings us to the most valuable new role in the software industry: the human in the loop. For a long time, having a human in the loop was seen as a temporary safety feature. Today, it is a strict financial requirement. We are entering an era where a developer's job is to watch the agent and catch it the moment it slips into an expensive failure state. The human acts as the ultimate kill switch. You check the output, verify the technical direction, and stop a runaway process before it bankrupts the sprint budget. Duolingo recently walked back its public stance on AI replacing workers. They, alongside Microsoft and Uber, realized a fundamental truth. Humans are actually the cheapest thinking engines on earth. A human developer has a highly flexible mind that runs efficiently on a sandwich and a decent night of sleep. They never bill the company a thousand times over just to stop and think.
Moving Forward
The bubble of infinite, cheap AI agents has popped, and it was defeated by a simple spreadsheet. As a younger developer entering the industry right now, this is incredibly validating news. It means our roles are highly secure, but our day-to-day responsibilities are fundamentally shifting. We are moving from writing every single line of code by hand to architecting and containing the systems that write the code for us. Start building strict routers into your AI stacks.
Implement aggressive containment protocols for your agents. Treat your token budget with the exact same respect you treat your memory heap. The future of software engineering doesn't belong to AI. It belongs to the engineers who know how to control the machine, contain the cost, and pull the plug when it drops the wrench.
