Amazon spent $1.8 million on a Claude project that never shipped. The task was embarrassingly simple — matching author records to book listings — and the bill ran 860 percent over budget, sat unnoticed for five months, and still failed anyway. Senior engineers at the company reportedly called it “catastrophically expensive.”
This isn’t a story about Amazon being bad at AI. It’s a story about what happens when AI agents meet the real world of metered billing, and why the tools we use to catch bugs don’t catch runaway token spend. If you run any kind of AI-powered pipeline, this is the cautionary tale you need.
What Actually Happened
The details come from an internal Amazon presentation first reported by the Financial Times. According to Tom’s Hardware, the project used Anthropic’s Claude Sonnet to match author records against product listings on Amazon’s retail site. It burned $1.8 million, blew past its budget by 860 percent, and never made it to production.
Two other overruns surfaced at the same meeting: a financial auditing tool that overshot by about $541,000, and a delivery acceleration system that added $134,000. The pattern is what matters here — this wasn’t one unlucky team, it was three separate projects in the same reporting period.
Amazon’s response was measured. “As with any new technology, we’re experimenting, learning and improving how we use it, including how we drive cost efficiencies,” the company said, adding that the cases involved a small number of groups inside a workforce of roughly 300,000. Internally, the tone was blunter. Amazon senior vice president Dave Treadwell told staff, “Please don’t use AI just for the sake of using AI.”
Why a Small Mistake Becomes a Seven-Figure Bill
Here’s the uncomfortable truth: the failure mode is baked into the product’s design. When a human writes buggy code, it throws an error and crashes. Someone gets paged, the build breaks, the problem announces itself. When a misconfigured AI agent hits a bug, it doesn’t crash. It retries. It loops. It re-sends the same prompt and quietly bills you for every attempt.
A job pointed at the whole catalogue instead of a sample produces no error at all. It just produces an invoice. And that invoice arrives on a monthly cycle, not in a build log — which is exactly how a runaway job runs for five months before anyone connects it to a number.
Per-token pricing makes this worse. Chatbots already burn tokens faster than we think, but AI agents fire off far more — every tool call, every self-critique pass, every retry adds to the meter. The Next Web put it well: a misconfigured agent has no crash signal, so the only real signal is a bigger bill at the end of the month.
The Awkward Part: Amazon Sells the Fix
Here’s where this gets almost funny. Amazon’s own cloud arm, AWS, sells the exact tools that would have caught this overspend. Bedrock offers batch inference at half price, a discounted Flex tier, prompt caching that can trim input costs by up to 90 percent, and prompt routing that pushes simple jobs to cheaper models. Anthropic’s smaller Haiku model costs roughly a third of the Sonnet model the project reached for.
The overspend came from picking the frontier model by default and leaving the guardrails off — exactly the mistake Amazon and Anthropic tell every other company to avoid. AWS cost expert Corey Quinn was predictably unsympathetic on X: “getting a bill with two commas that you weren’t expecting must be so hard for you.”
This Isn’t Just Amazon’s Problem
Before you shrug this off as a mega-corp problem, consider the pattern. Uber’s chief technology officer said in April that the company had already used up its entire 2026 budget for Claude Code. Developer Peter Steinberger’s famous $1.3 million OpenAI bill from a runaway background job showed the same failure mode at individual scale. Token prices have fallen roughly 98 percent over the past two years, yet enterprise AI bills keep climbing. Cheap tokens don’t help when your agents consume a million times more of them.
Amazon even scrapped an internal leaderboard that ranked employees by AI usage after staff gamed it by inflating their token consumption. Incentives, it turns out, matter more than metrics.
What This Means for the Rest of Us
Most teams will never see a seven-figure AI bill. But the mechanics scale down perfectly. A misconfigured job that runs for a weekend, a web scraping loop that forgets to stop, an agent that retries a failing API call for hours — these are the same bug, just smaller numbers. Here’s what actually helps:
- Set hard spend caps before you deploy. Every agent pipeline needs a per-job token budget, not a monthly invoice review. Amazon’s engineers are now building exactly these guardrails internally.
- Right-size the model. Frontier models are for frontier problems. Routine matching, extraction, and formatting tasks belong on the cheap tier. I wrote a full guide on cutting LLM API costs with Toolgz if you want the details.
- Turn on the cost tools your provider already sells. Batch inference, prompt caching, and prompt routing exist precisely for this. Most of them are a checkbox away.
- Alert on spend, not just errors. If your dashboards only page you when something breaks, a silently looping agent will never page anyone.
- Watch the loop patterns. Retry loops, self-critique chains, and reflection passes are where agents burn tokens invisibly. Log them and review them.
- Consider local models for routine work. If a task is boring and repetitive, it may not need a metered API at all. Local-first coding agents like Collie prove you can run capable agents without per-token anxiety.
I practice some of this in my own setup. We keep a fast, cheap model for routine automation and cron jobs, and only reach for the premium model when quality actually matters — editorial review, complex reasoning, the occasional hard debugging session. It’s not glamorous, but it’s the difference between an AI bill you can plan for and one that shows up uninvited.
The Governance Lesson
The real takeaway from Amazon’s $1.8 million oops isn’t financial. For a company with quarterly revenue above $180 billion, the blown budgets don’t add up to 0.1 percent of a single month’s sales. It’s a governance lesson: AI spend needs owners, budgets, and alarms, the same way any other infrastructure cost does.
This is the same gap that made AI agent security suddenly everyone’s problem — agents are being deployed faster than the guardrails around them. And it’s the same reason AI coding assistants hallucinating package names became a supply chain concern. The tools are powerful; the discipline around them is still catching up.
FinOps for agents is about to become a real product category rather than a checkbox. Whoever ships credible per-job spend caps, live token dashboards, and cheap fallback routing gets to sell into a market that just watched the biggest cloud on earth lose seven figures to a script that wouldn’t stop retrying.
In the meantime, the lesson costs nothing: the frontier model isn’t the default. The bill is part of the code review. And if your agent ever runs for five months without anyone asking what it costs, you’ve already spent the budget — you just haven’t received the invoice yet.