The Agent Deployment Inequality, and the Footnotes That Fail Its Own Standard

An agent adds value when the probability of success exceeds the time a human needs to verify the work divided by the time a human needs to do the work themselves. P(success) > T(verify) / T(do).

David Tepper, CEO of Pay-i, put that inequality in front of McKinsey senior partner Lari Hämäläinen on July 8, 2026, and it is the most useful thing published on agent economics this year. Work the example he gives. A task takes a human two hours to do and six minutes to verify. T(verify) over T(do) is roughly 5 percent. The agent needs to succeed 5 times out of 100 to be net positive.

Five percent. That number reframes what “good enough to deploy” means for an enormous class of work, and teams reject agents clearing the bar by a wide margin because the bar was never calculated. Adopt the inequality. Then keep reading, because the interview containing it fails, in its own footnotes, the discipline it prescribes.

The Agency Tax Is Where the Math Actually Lives

The clean version of the inequality holds under one condition, and Tepper names it himself: failure has to leave the environment unchanged. A document-processing agent that fails produces a bad document. You throw it away and the world is where it started. His counterexample is sharper: “A customer service agent that tells a customer they can refund a nonrefundable trip has changed the environment.”

Now the arithmetic breaks. You pay the original cost, then a recovery cost on top of it, and the formula bounds the recovery cost at nothing. Tepper calls the full picture the agency tax: verification cost plus rework cost, “and in production, rework is rarely zero.”

That second term is where most enterprise use cases live. Refunds, tickets, schema migrations, outbound messages, anything that writes. The 5 percent threshold applies to the read-only, discard-on-failure half of the portfolio. The write half needs an honest rework estimate before the inequality means anything, and Tepper’s assessment is blunt: “most enterprises have not done that calculation use case by use case.”

The Taxonomy Decides Whether the Math Applies at All

Before running the numbers, you have to know what you are running them on. Tepper’s three-way split is clarifying enough to repeat.

A workflow is traditional software with gen AI bolted into individual steps. Cost is bounded per invocation. A pipeline is a predetermined sequence of steps that call an LLM. Cost is bounded per call times a known number of calls. A true agent receives a broad objective and decides at runtime what to call and for how long. Cost is unbounded per task.

His warning to buyers deserves to be quoted directly: “Most vendors selling you an agent are selling you a pipeline. That is often exactly what you need, but you should know what you are buying.”

The distinction matters for evaluation, and here Tepper says the thing that organizes the rest of this piece: “When an agent fails, it almost never fails on the last step. It fails three steps earlier, potentially in a way the last step covers up. If you only judge the output, you are grading the cover-up, not the crime.”

LLM-as-judge survives for workflows and pipelines. It breaks for true agents, because agents construct their own prompts internally, so you cannot assemble a database of acceptable inputs to grade against. We have argued a version of this in evaluation-driven agent operations. Tepper’s formulation is better than ours.

Grading the Trajectory of the Interview Itself

Take him at his word. Judge the trajectory, not the endpoint. We checked the citations underneath the interview’s numbers on July 16, 2026, reading both arXiv papers directly from their abstract pages. Three things do not hold.

The 1,000x attribution. Tepper refers to “the Microsoft and Stanford finding that agentic workflows consume roughly 1,000 times more tokens.” McKinsey’s own footnote points to Bai et al., How do AI agents spend your money? (arXiv:2604.22750, April 2026). The author list is Longju Bai, Zhemin Huang, Xingyao Wang, Jiao Sun, Rada Mihalcea, Erik Brynjolfsson, Alex Pentland, and Jiaxin Pei. That is an academic team. Mihalcea is at Michigan, Brynjolfsson at Stanford, Pentland at MIT. No Microsoft study is involved. The 1,000x figure itself is real and sits in the abstract; the institutional label attached to it is invented somewhere between the paper and the transcript.

The Tokenomics description. McKinsey’s footnote characterizes the paper as “Analysis of 20 production agentic coding workflows on SWE-bench and internal benchmarks.” The paper (Salim, Latendresse, Khatoonabadi, Shihab, arXiv:2601.14470, January 2026) says it analyzes “execution traces from 30 software development tasks performed by the ChatDev framework using a GPT-5 reasoning model.” Not 20. Not SWE-bench. Not production. The authors label their own findings preliminary. The headline numbers hold up: code review consumes 59.4 percent of tokens, input tokens are 53.9 percent of the total. Those are safe to cite, with the preliminary caveat the authors asked for.

The one that bites. Tepper argues frontier models justify their per-token premium because “a more capable model lifts P(success) and often shrinks T(verify).” Bai et al., the paper McKinsey cites for the 1,000x figure, reports the opposite pressure in the same abstract: “higher token usage does not translate into higher accuracy; instead, accuracy often peaks at intermediate cost and saturates at higher costs.” Spending more does not monotonically buy P(success). The citation undercuts the claim it was brought in to support.

Three defects, one direction: the endpoint numbers survive, the path to them does not. Which is precisely the failure mode Tepper described three paragraphs earlier in his own interview.

What Is Real Is Worth Acting On

The distinction has to stay crisp. The data is good; the framing around it drifted.

Bai et al. is worth reading in full for three findings we verified in the abstract. Runs on the same task differ by up to 30x in total tokens, which means your cost forecast needs a distribution rather than an average. Cost is driven by input tokens rather than output. And frontier models “fail to accurately predict their own token usage (with weak-to-moderate correlations, up to 0.39) and systematically underestimate real token costs.” The agent cannot forecast its own bill. Every capacity plan built on asking the model what it will spend rests on nothing.

Tepper’s operating numbers are similarly worth having. Inference cost for a fixed model size has compounded down roughly 6.67 percent per month since 2022, about an 86 percent decline for models of similar size, and yet cost per completed task “has gone up steadily in every workload we see.” His line on this is the right one: “Tokens are not value. Tokens are the bill. The bill tells you what you spent. It does not tell you whether you should have spent it.” We have written about cost per completed task as the CFO’s metric and will not re-litigate it here.

Two more, useful for planning. Roughly $3 million of annual spend concentrated with a single provider for a single model is where shared infrastructure gives out and provisioned capacity starts, and the most common mistake at that threshold is siloing capacity pools per use case: “We see enterprises paying for two or three times the capacity they need because of this one mistake.” Cached input tokens run 75 to 90 percent cheaper, but only when the prompt is structured to hit cache, and most are not.

One claim gets no such treatment. Tepper asserts “there is a category in which 95 percent of enterprises are not measuring their returns,” and no source is attached. Pay-i sells measurement infrastructure. Treat that number as a vendor-side estimate, useful as directional intuition and unusable in a board deck.

The Habit That Compounds

We tracked McKinsey’s slow drift toward governance language across three articles back in March, in the scaling design problem. This interview is the fourth data point and the strongest: they have arrived at a real decision rule with a real caveat attached. That is progress worth acknowledging.

The footnote drift is not bad faith. It is what deadlines do to every organization, including this one, and it is exactly why measurement discipline has to be architectural rather than a matter of individual diligence. Nobody checks their own citations under pressure. Systems check citations.

So do three things this quarter.

Run the inequality per use case, not as a company-wide policy. Write down T(verify) and T(do) in minutes for your ten highest-volume tasks. Some will show a threshold near 5 percent and you are leaving value on the table today.

Add the rework term honestly. For every use case where failure writes to the world, estimate recovery cost and put it in the denominator’s neighbor. If you cannot estimate it, that use case is not ready.

Check the provenance of any number before it enters a board deck. Open the paper. Read the abstract. Confirm the authors, the sample size, and whether the study says what the person citing it says it says. That last habit takes ten minutes and it is the one that compounds, because the alternative is a strategy built on a number that grades the cover-up.

---

This analysis synthesizes Cost versus value: Managing agentic AI system performance (McKinsey Quarterly, July 2026), How Do AI Agents Spend Your Money? (Bai et al., April 2026), Tokenomics (Salim et al., January 2026), and How we built our multi-agent research system (Anthropic, June 2025).

Victorino Group helps engineering organizations calculate the deployment inequality use case by use case, rework term included, before the agent ships. Let’s talk.