A number the industry keeps recirculating.
In June 2025, Gartner published a prediction that has since become the most-quoted line in every agentic AI budget conversation: over 40% of agentic AI projects will be canceled by the end of 2027. Source: Gartner, "Predicts Over 40% of Agentic AI Projects Will Be Canceled by End of 2027," June 25, 2025. It's over a year old now, and it still gets a fresh headline every few weeks, most recently Forbes, July 7, 2026, because the deadline it names is getting close enough to feel real. 2027 is not a hypothetical future anymore. It's next year.
Gartner names three causes, in this order: escalating costs, unclear business value, and inadequate risk controls. A January 2025 Gartner poll of 3,412 webinar attendees found only 19% of organizations had made significant investment in agentic AI, 42% conservative investment, 8% none at all, and the remaining 31% still deciding. Most of what gets canceled by 2027 hasn't even been built yet. That's the useful part of this story: it's not a postmortem of failures already locked in, it's a description of a failure mode you can still route around.
Three reasons, one root cause.
Read the three causes side by side and two of them collapse into the same problem. "Escalating costs" is a bill that grew faster than anyone budgeted for. "Unclear business value" is what that same bill looks like when nobody can tie it back to a result. Both are downstream of the same missing thing: cost-per-request visibility. A team that can't see what an individual agent run cost also can't compute what it returned, and a project whose ROI can't be computed reads, to a budget committee, exactly like a project with no ROI. "Inadequate risk controls," the third cause, is where cost governance and safety governance start to overlap, too, since an agent that can spend without a ceiling is the same shape of problem whether the thing it's overspending is dollars or scope.
This isn't a claim that every canceled pilot dies of cost alone. Some die because the use case was wrong from the start. But cost is the one failure mode that's fully within an engineering team's control, independent of whether the underlying product idea was sound, and it's the one this post is about.
What defensive governance looks like right now.
The response so far has mostly been reactive, built after a bill everyone knew was one they'd already have to answer for. Meta's internal AI usage dashboard tracked employees consuming over 60 trillion tokens in a single month, one individual accounting for roughly 280 billion of it alone, before the dashboard itself got shut down rather than keep surfacing a number nobody wanted to look at. Uber burned through its entire 2026 Claude Code budget in the first four months of the year and answered with a flat $1,500-per-engineer monthly cap. Both are the same move: cap spend after the fact, once the number is already embarrassing.
On July 15, 2026, a different kind of response shipped as a product feature instead of a policy memo. Tetrate added token brokering to its Agent Router Enterprise platform: every inference request gets checked against a policy for spend, availability, and data sovereignty before it's allowed to route, actual spend is measured continuously against that policy, and a circuit breaker trips when a budget threshold is crossed, failing the request over to an approved, cheaper alternative, often a private model instead of a frontier one. Source: PR Newswire, "Tetrate Adds Token Brokering Capability for AI Code Gen Cost Management," July 15, 2026; ITBrief, "Tetrate adds token broker to control AI agent spend". It's a genuinely useful thing to exist, and its existence as a shipped, GA product is itself the signal worth noticing: budget governance for agents is turning into its own category, not a spreadsheet someone updates after the invoice arrives.
A circuit breaker and a router solve different problems.
It's worth being precise about what a circuit breaker actually does, because it's easy to mistake it for the whole fix. A circuit breaker watches spend against a policy and fires once a threshold is crossed. That's a real and necessary control: it's the thing standing between a misconfigured retry loop and a five-figure surprise on next month's invoice. But by construction, it only acts after the threshold is already close to being breached. Every request below that line runs at whatever cost it would have run at anyway.
| Circuit breaker | Quality-aware router | |
|---|---|---|
| When it acts | After a policy threshold is crossed | Before every request is sent |
| What it optimizes | The worst case (runaway spend, a single session or org going over budget) | The baseline (the median request's cost) |
| Failure it prevents | A five-figure surprise from an unbounded loop | Paying frontier prices for a request a cheaper model could handle |
| What it needs to work | An accurate real-time spend meter and an approved fallback | A quality signal per request, not just a price signal |
Neither one substitutes for the other, and the failure mode of picking just one is asymmetric. A breaker with no router underneath it means every request under the threshold pays full frontier price, so the threshold gets hit sooner and more often than it needs to. A router with no breaker above it means there's no hard ceiling if something genuinely runs away, an infinite retry loop will happily keep routing to the cheapest model forever and still rack up a bill nobody approved. A governed agent needs both, and most of the "40% canceled" stories are, underneath the label, a project that shipped with neither.
Building the guard, not just the router.
The router decides what a single request costs. The guard decides how many requests a task is allowed to make before someone has to sign off on more. They're two small, separate pieces of logic, and most teams only build the first one:
class BudgetGuard:
def __init__(self, session_budget_usd, warn_at=0.8):
self.spent = 0.0
self.budget = session_budget_usd
self.warn_at = warn_at
def check(self, projected_cost_usd):
if self.spent + projected_cost_usd > self.budget:
raise BudgetExceeded(
f"would spend ${self.spent + projected_cost_usd:.2f} "
f"of a ${self.budget:.2f} session budget"
)
if self.spent / self.budget >= self.warn_at:
log_warning("session at %.0f%% of budget", 100 * self.spent / self.budget)
def record(self, actual_cost_usd):
self.spent += actual_cost_usd
guard = BudgetGuard(session_budget_usd=5.00)
for step in agent_loop(task):
guard.check(projected_cost_usd=step.estimate())
response = client.chat.completions.create(
model="auto", # router picks the cheapest model above the quality floor
messages=step.messages,
)
guard.record(actual_cost_usd=response.usage.cost_usd)
if guard.spent / guard.budget >= guard.warn_at and not step.confident:
break # stop and return the best answer so far, don't keep exploring on a hunchThe break condition in the last line matters more than it looks. It's a direct response to what the token-variance research on coding agents keeps finding: the expensive runs on a task aren't usually the ones that found something extra, they're the ones that kept exploring after the model stopped being sure. A guard that only enforces a hard ceiling misses that; a guard that also asks "are we still confident" before spending the next dollar catches it earlier, at a fraction of the cost.
The checklist that keeps a pilot off the cancelled list.
- Cost per request, not cost per month. A monthly total tells you that spend grew. It can't tell you which requests were worth it and which weren't, and "unclear business value" is exactly the gap that leaves open.
- A quality floor, not just a price floor. Routing to the cheapest model only works if you can tell when it got the answer wrong. Without a verification step, "cheaper" and "worse" are indistinguishable until a customer notices.
- A budget guard with a soft edge. A hard stop mid-task looks like an outage to whoever's waiting on the result. A guard that checks confidence before it checks the ceiling can return the best answer so far instead of nothing.
- A review cadence tied to a business metric, not a token count. "We spent $40,000 on inference this quarter" is not a fundable or cancelable fact by itself. "We spent $40,000 on inference and it closed 1,200 tickets that used to take a human 20 minutes each" is.
Where Nadir fits.
Nadir is the router half of this, not the breaker half, and it is worth saying plainly rather than blurring the two together. The Decision API targets about 100 ms, makes no model-provider call, and returns a model-and-effort receipt. Join it to actual usage and business outcomes in shadow mode; complete non-streaming responses can optionally enter a verifier, while streaming bypasses post-generation verification.
That directly addresses two of Gartner's three causes: it lowers the baseline that turns into "escalating costs," and it produces the per-request record that turns "unclear business value" into a number someone can actually defend in a budget review. It does not replace a session-level or org-level circuit breaker, the kind Tetrate shipped in July, and a genuinely runaway loop still needs a hard ceiling above the router, not just a cheaper price for every request inside it. The two layers described in the chart above are not competing for the same job. Most projects heading toward Gartner's 40% are missing one of them, not choosing the wrong one.
The integration is two lines: point the base URL at Nadir, set model="auto". What that buys you isn't just a lower bill, it's the answer to "what did this cost and was it worth it" on every single request, which is the thing "unclear business value" means you don't currently have.
Related reading.
- Meta employees consumed over 60 trillion tokens in a single month before the internal dashboard tracking it got shut down.
- Uber exhausted its entire 2026 AI budget four months into the year.
- Coding agents burn 1,000x more tokens than chat, and the same task can cost 30x more on one run than another — Stanford and Microsoft measured where the money goes.
- Spend controls report cost after the fact and only for one vendor. Routing changes the cost of the next request across every vendor.
- A 680x gap separates the top 1% of AI spenders from the median. A flat per-seat cap can't fit a curve that skewed.
Sources: [Gartner, "Predicts Over 40% of Agentic AI Projects Will Be Canceled by End of 2027," June 25, 2025](https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027). [Forbes, "Why 40% Of Agentic AI Projects May Be Canceled By 2027," July 7, 2026](https://www.forbes.com/sites/robertszczerba/2026/07/07/why-40-of-agentic-ai-projects-may-be-canceled-by-2027/). [PR Newswire, "Tetrate Adds Token Brokering Capability for AI Code Gen Cost Management Through Agent Router Enterprise," July 15, 2026](https://www.prnewswire.com/news-releases/tetrate-adds-token-brokering-capability-for-ai-code-gen-cost-management-through-agent-router-enterprise-302826151.html). [ITBrief, "Tetrate adds token broker to control AI agent spend"](https://itbrief.news/story/tetrate-adds-token-broker-to-control-ai-agent-spend).