Price the Diff, Not the Trajectory

Analytics companies sell compute, not analytics. More precisely, they sell compute metered against workloads whose efficiency they control. The vendor owns the optimizer, the file format, the caching layer. Every efficiency improvement is a revenue cut, so efficiency ships on competitive-pressure timelines, not engineering timelines. The buyer's own data team gets conscripted into recovering margin the vendor's defaults gave away.

Token pricing inherits this and makes it worse. The vendor controls output verbosity through training decisions. The vendor designs the tokenizer, so the billing unit itself is proprietary and non-comparable across providers. Reasoning tokens bill you for text you cannot inspect, in quantities the vendor's training run determined. And there is no clean bake-off: same-prompt-two-bills does not isolate efficiency from capability the way same-query-two-bills does in databases. Per-token prices have collapsed anyway, because model swaps are cheap where warehouse migrations are not. But the structural incentive stands: the party that controls verbosity profits from it.

Agentic workloads add a dimension token pricing cannot see. An agent that takes forty turns instead of twelve to complete a task is a 3x cost event that per-token billing renders invisible as an efficiency failure. It just looks like usage. Nobody meters the trajectory.

Outcome pricing is insurance, not pricing

The pitched alternative is outcome pricing: pay when the agent succeeds. It works, in exactly one place. Customer support agents from Sierra and Intercom bill per resolved conversation, and Sierra crossed $150M in ARR on the model. Look at why it works there: a support resolution has a cheap mechanical proxy. The customer stops replying and does not reopen. Adjudication costs approximately nothing.

Everywhere adjudication is expensive, outcome pricing stalls. Coding agents repriced from $500 a month to $20 a month and stayed on subscriptions with credit meters, because nobody can cheaply verify that a merged pull request is correct code. And even where the model works, it exhibits predictable pathology. The vendor defines "resolved," so contracts drift into blended per-conversation billing for interactions that resist the outcome definition. You swapped a rigged meter for a rigged referee.

The deeper problem: pricing outcomes on a probabilistic system is underwriting, not pricing. The vendor is insuring a distribution of success rates across your task mix. That imports adverse selection, moral hazard, and premiums that must price the tail. Every "pay per resolution" scheme either charges for the worst-case task mix or narrows the covered definition until the outcome means something small enough to underwrite.

Path invariance

There is a third structure. Price the episode as a function of two things only: the start state and the committed diff. Everything between them, the iteration, the backtracking, the retries, is the vendor's internal cost.

Call it path invariance. It is how a fixed-bid contractor prices a kitchen. You pay for the kitchen, not for how many times they re-measured.

Path invariance does one thing neither incumbent model does: it assigns the efficiency incentive to the party holding the steering wheel. Under per-token pricing, the vendor profits from trajectory waste. Under path-invariant pricing, every wasted iteration comes out of vendor margin. The incentive that has been misaligned since the data warehouse era flips sign.

The machinery has four parts, and each is mechanically checkable. No referee anywhere.

Quote at task start. The vendor inspects the start state and the request, quotes a price, the customer accepts. This is not a prediction of the trajectory, which no forward pass can make. It is an envelope: a commitment plus runtime enforcement. Spend caps are enforceable per action even when trajectories are not foreseeable per pass. The quote also kills the boundary-gaming problem that plagues every pricing unit. Bundle ten tasks into one request and you receive a ten-task quote.

Stage everything. The episode runs sandboxed. External effects queue rather than execute. This makes abandonment genuinely free, which is what makes free-on-failure an honest promise rather than false advertising. Without staging, an abandoned episode leaves half-sent emails and half-mutated tables, and "free" failure hands the customer a cleanup bill. The sandbox is not a safety feature bolted onto the pricing model. It is the thing that makes the pricing model's core promise true.

Bill at the commit gate. The billing event is mechanical: the merge that passed CI, the artifact persisted to the workspace, the email released from the queue. The gate certifies that work terminated and was accepted. It never certifies that work was good. That distinction is the entire advantage. Support vendors are stuck litigating outcome definitions precisely because their billing event tries to prove quality. Separate the two and the negotiation disappears.

Warranty as a separate instrument. Quality lives where it lives everywhere else in the economy: warranty, reputation, repeat purchase. The contractor gets paid at completion and carries an obligation if the roof leaks. A reverted commit triggers a warranted fix, not a clawed-back invoice. Mixing settlement into billing is how you end up with revenue that matures like a bond.

Queries are not episodes

One boundary question decides the model's scope. A one-shot factual read has no trajectory, no staging, no meaningful diff. It is a query, not an episode, and it belongs on a subscription. Episodes are for work that changes state: code merged, documents persisted, actions executed, artifacts compiled into something durable.

Classify by terminal state, not by prompt. If the work product persisted, it was an episode, billed at commit. If nothing persisted, count it against the subscription. Ex post, mechanical, no classifier arguing with customers. Queries and episodes are one business the way SELECT and INSERT are one database.

This also predicts what customers persist, which becomes the revenue base: decisions and the reasoning behind them. Reports go stale. A decision plus its rationale appreciates every time someone asks why. The leading indicator of account health under this model is decision velocity, not data volume, and it correlates with the customer's own health. Revenue grows when the customer's decision-making grows.

Why it does not exist yet

Not because of verification. Merge-gated billing needs no verification breakthrough. Two blockers, neither of them mechanism design.

First, the actuarial cold start. Quoting requires a loss table: the distribution of episode costs conditioned on start-state features. Building the table requires episode volume. Volume requires quotes customers accept. Sierra broke the circle with nine figures of capital and Fortune 50 sales patience. Intercom broke it by picking the most homogeneous task distribution in software. Everyone else is stuck in the loop.

Second, procurement legibility. Enterprise budgets are headcount-shaped. Seats survive not because they price anything correctly but because they are the unit finance departments can approve. Episode pricing is work-shaped, and work-shaped pricing loses to headcount-shaped procurement even when it is strictly better.

Which predicts where the model lands first: buyers whose budgets are already work-shaped. Agencies, dev shops, support BPOs, anyone who bills their own customers per deliverable and can pass the unit straight through. No translation layer required.

The moat is the loss table

Follow the actuarial requirement to its conclusion. If quoting accuracy is the binding constraint, the durable asset in agentic pricing is not the model. Models are commoditizing on schedule. The asset is the proprietary distribution of episode costs by start-state features, accumulated from observed trajectories with known terminal outcomes.

That table accrues wherever the episode boundary is observable: where the trajectory, the terminal condition, and the acceptance event are all visible to one party. Routers see breadth without episode depth. Model providers see depth without cross-task breadth. Harness and platform vendors, the ones who own the commit gate itself, see both.

Most of them are currently monetizing that position per token or per seat, which is to say, ignoring it. The first vendor to treat trajectory data as underwriting data rather than exhaust will not have a better model. It will have a better quote. In fixed-bid contracting, the better quote wins the job.

We spent decades letting compute vendors define the meter. The episode gives us a unit the vendor cannot pad and the buyer cannot dispute: the diff you chose to keep. Price that.