Agent ROI Begins at the Fabric Level

Every enterprise is building agents right now. Payers are wiring them into claims intake, providers into prior auth and scheduling, life sciences teams into regulatory documentation. The build pace is fast and getting faster.

Underneath the build pace is a quiet, margin-killing problem. Most organizations measure AI return at the wrong altitude, and the number they report to the board bears little resemblance to what the agents cost to run.

This post opens a series on the economics of enterprise intelligence, built on a framework we call the AI Capacity Doctrine. The thesis is short. AI behaves like a dynamic, scalable layer of operational capacity, and its financial yield depends on how it's built, measured, and tuned. Budget it like a software license, and you'll misread every number that follows.

The trap of project-level ROI

The market is full of platforms that evaluate AI at the project level and stop there. Pick a business unit, estimate hours saved across a generic timeline, multiply by a loaded labor rate, declare victory.

Project-level ROI is a vanity metric. It's a blunt instrument that glazes over token waste, latency bottlenecks, model drift, and API cost spikes. The optimistic top-line estimate becomes a blanket, and the operational hemorrhaging underneath it never shows up on the slide.

Defensible ROI can't be calculated from the top down. It starts at the agent, and it's captured at the fabric.

Define the agent, then get more juice from the squeeze

Start by defining exactly what each agent does at a tactical level, then hold it to KPIs at that level. Is it routing data to the right place? What's its accuracy score against a validated answer? What's its exact cost per execution, in tokens and in dollars?

We wrote up the scorecard we use for this in Is This Agent Earning Its Place? The short version is that an agent without a cost-per-outcome number is an agent you're guessing about.

KPIs are half the job. If your platform measures performance without giving you the toolset to change it, you're admiring a problem. Measuring a static, inefficient process produces a highly accurate receipt for overspending (a very tidy receipt, still a receipt).

The cost and quality matrix

Getting more juice from the squeeze requires the visibility to compare models dynamically, per task. A multi-billion-parameter frontier model is the wrong tool for most of what an agent does in a day.

Map each agent step onto a cost and quality matrix and you can pick the exact model for the exact job. The pattern we see in production looks something like this. A lightweight, specialized model handles the routine sorting and extraction, the bulk of the volume, for pennies. A premium frontier model gets called for the narrow slice of steps that need deep reasoning. The illustrative split below is a starting point, and the right ratio for your workflow is something you measure, not assume.

This is the same logic we laid out in Right model, right job, with one addition that matters in healthcare. Quality has to be measured against real workflows. In our χ-BENCH testing, the best frontier agents completed only 28% of complex healthcare workflows end-to-end. Paying frontier prices for a 28% completion rate on the hard steps is both a cost and a quality problem.

Optimizing along this matrix is how you protect the bottom line. It also requires one architectural capability that most agent stacks skip. Model independence.

If you can't swap models, it's someone else's ROI story

If your agent architecture is hardcoded into a single LLM provider's ecosystem, you don't own your margins. The frontier lab does.

Every time that provider changes its pricing roadmap, deprecates a model, or has a bad Tuesday, your operational capacity hangs in the balance. Your growth funds their enterprise value. That's a fine outcome for them and a structural leak for you.

We've made the case for owning the layer above the model before, in Own Your Models and in How to Protect High-Stakes AI Workflows From Vendor Turbulence. The ROI angle is the sharpest version of that argument. Model independence is the difference between a cost you control and a cost that controls you.

The agentic paradox

Here's the harsh truth organizations are learning the expensive way. If you can build agents, you can't measure them.

Low-code tools have made building an agent a commodity. Anyone can prompt a bot into existence in an afternoon. The engineering challenge, and the economic moat, sits in the fabric layer that runs beneath every agent. That fabric has to continuously monitor token consumption, keep an audit trail of every decision, and attribute execution cost back to the workflow that incurred it.

Without an independent orchestration fabric doing that work, true financial measurement is impossible. You get a dashboard of estimates and a bill that keeps surprising you.

The bottom line

Building agents without an underlying orchestration fabric is a recipe for operational deficit. The early, localized wins are real. Then you scale across the enterprise, and the unmonitored infrastructure costs outrun the efficiency gains, usually before anyone notices the crossover.

Don't lose margin by gaining a false sense of agentic ROI. Real return requires three things working together: 1) granular KPIs at the agent level, 2) dynamic model swapping across a cost-and-quality matrix, and 3) governance at the fabric level that turns every execution into an auditable, attributable line item.

Before you pick your next AI model, make sure you own the layer above it.