DEV Community

Cover image for Enterprises, should you be thinking about cost per outcome, not cost per task?
Sumanth Prasad
Sumanth Prasad

Posted on Edited on

Enterprises, should you be thinking about cost per outcome, not cost per task?

A case for outcome-based pricing, and the case against


When a finance team reviews what the organization spent on AI last quarter, the numbers usually come back in tokens, seats, or credits. Those units describe consumption, not what the business received in return, and that disconnect is a large part of why the discussion has started moving from cost per token toward cost per task.

That move is a reasonable one, but I think it stops short of where it should land. The unit most organizations genuinely care about is the outcome, which is the result the work was meant to produce. There is already a well-established way to buy outcomes rather than effort, and most enterprises use it regularly: the Statement of Work (SOW) they sign with a consultancy or systems integrator to deliver a defined result.

To be clear about where I stand: I think outcome pricing is where the most valuable enterprise AI will eventually be bought. But the opposing case is strong, and the honest conclusion is less settled than that sounds. What follows argues for outcome pricing and then puts the counter-case as fairly as I can, because the industry has not actually resolved this.


The pricing ladder

AI Pricing Ladder

Each step up this ladder moves the thing you pay for closer to the result you care about, and it shifts the risk of wasted effort from the buyer toward the vendor.

Unit What you're really buying Who absorbs waste Services analogy
Token Compute Buyer: retries, long prompts, loops Time & materials
Task A unit of work Shared: the task can succeed and still miss the point Piece-rate labor
Outcome A business result Vendor: failed attempts are on them Fixed-fee SOW

The market has already begun to move in this direction, though not in a straight line, and the clearest examples so far are in customer support and sales. Intercom charges $0.99 per resolution for its Fin agent (Intercom), and $10 per qualified lead for Fin for Sales, with the customer defining what counts as qualified (Intercom blog). Sierra charges primarily when its agents reach the outcomes a client has agreed to (Sierra).

Salesforce is a useful counter-example, because it shows the pull in the other direction. Agentforce launched at $2 per conversation and later moved to Flex Credits priced at roughly $0.10 per action (Salesforce, Salesforce press release). A charge per action is a usage unit, not an outcome one; it sits closer to the token end of the ladder than to the outcome end. One reading is that even a vendor with every incentive to price on outcomes found it easier, at scale and across many customers, to meter the work than to agree on what a delivered result was worth. That tension runs through the rest of this piece.

These examples share a trait that is easy to miss: an outcome in support or sales is a discrete, loggable event, which is what makes it billable. The largest token budgets today sit elsewhere — code generation and refactoring, content production, document analysis — where the outcome is just as real but harder to pin down, because "maintainable code" or "on-brand copy" does not reduce to a single logged event the way a resolved ticket does. Most enterprise value is like that, so outcome pricing will take hold first where a result is cheap and quick to verify, and spread slowly, if at all, into work where "done" is a matter of judgment. The argument that follows is a claim about direction of travel, not a prediction that everything ends up priced this way.


Why "per task" isn't enough

This gap between effort and result shows up wherever tokens are spent, not only in agents that take actions on a live system. A task is something the model does, while an outcome is a change in the state of the business, and the two are not interchangeable. A few examples make the distinction concrete:

  • A coding assistant can spend a million tokens producing a working payment module, but if the code is tangled enough that the next change costs another million tokens to understand and fix, the tokens billed bore little relation to the value delivered.
  • A content tool can generate 500 product descriptions, but if a person has to rewrite most of them to clear the brand bar, the business paid for drafts rather than for copy it could publish.
  • A support agent can close 1,000 tickets, but if 30% of them reopen within a week, the business did not receive 1,000 resolutions.
  • A migration agent can run a script against 500 servers, but if the applications do not pass acceptance testing, nothing has actually been migrated.

Take the coding assistant example, when you pay by the token, a model that solves a problem inefficiently, with more reasoning, more retries, and more verbose output, costs you more than one that solves it cleanly, and can cost you a second time when the messy output has to be reworked. Metering can end up charging the most for exactly the work you would least want to pay for.

Moving the unit from the token to the task is a genuine improvement, because it finally counts completed work instead of compute consumed, and a growing body of analysis argues that cost per completed task, not cost per token, is the number enterprises should actually manage to (Forbes). But it does not close the gap, because a task the model marks done is still not the same as a result the business can use. The distinction is by now well documented: a completed task is a unit of work the vendor defines and controls, while a business outcome is the result the customer realizes in its own operation, and the gap between the two decides who carries the risk when the value fails to land (Software Pricing Partners). Completion is not value. One analysis points out that an agent can finish 95% of the tasks it is handed and still return zero ROI, because completion rate is not the same as outcome rate (DigitalApplied), and another notes that an agent completing thousands of tasks proves nothing until that output is tied to a business result that existed before it arrived (Glean).

Task-based pricing also rewards the wrong thing. As Wharton's Ethan Mollick has put it, charging per task incentivizes quantity over quality, pushing organizations to optimize for the number of tasks rather than the strategic impact of the work (Getmonetizely). That is why buyers are already pressing past it: BCG finds that AI agents are driving customers to demand a tighter connection between price and value delivered, with more of them wanting to pay solely for the outcomes their software produces (BCG). Per-task pricing still leaves the buyer holding the risk that matters most, which is whether the work moved the business forward at all. That is precisely the risk organizations have long paid professional services firms to carry on their behalf.


We already know how to buy outcomes: the SOW

When an organization hires a consultancy or systems integrator to migrate a data center or stand up a fraud model, it does not pay per keystroke or per hour of deliberation. It signs a Statement of Work that sets out the terms of the engagement:

  1. Scope: what is included and what is not
  2. Deliverables: the concrete artifacts or states to be produced
  3. Acceptance criteria: how both sides will agree the work is complete
  4. Milestones and payment schedule: money released as value is demonstrated
  5. Assumptions and dependencies: what the client must provide, such as access, data, and decisions
  6. Change control: what happens when the scope moves
  7. Warranty and remedies: what happens if a deliverable fails after acceptance

Each of these clauses has a direct equivalent when the work is carried out by an AI agent rather than a consulting team.


The Agentic SOW

SOW clause Professional services version Agentic equivalent
Scope "Migrate 120 Tier-2 apps" The workflow boundary the agent owns, e.g. "all Tier-1 billing inquiries in English via chat"
Deliverable Migrated, running apps A verified result: a resolved case, a reconciled invoice, a merged PR that passes CI
Acceptance criteria UAT sign-off An automated eval plus a business check: no reopen in 7 days, CSAT ≥ 4, a defect rate below X% on a sampled audit
Milestones Wave 1, Wave 2… Graduated autonomy: shadow mode → human-approved → autonomous at a set volume
Assumptions / dependencies Client provides SMEs and access Client provides API access, clean knowledge sources, escalation paths and policy definitions
Change control Change request process Changes to the outcome definition, a new intent category or a policy change trigger repricing
Warranty 90-day defect fix Clawback or credit if an "accepted" outcome is reversed (refund issued in error, ticket reopened)
Pricing Fixed fee per milestone A fee per accepted outcome, often on top of a platform base

The underlying change is that the vendor is no longer selling capacity; it is committing to deliver a result. Tokens, model choice, retries, prompt engineering, and orchestration become the vendor's cost of goods sold, in much the same way that a consultancy absorbs its own bench time and rework rather than billing the client for it.


A worked example: accounts payable

The following illustrates how an Agentic SOW might read for invoice processing:

Outcome: An invoice is received, matched against the PO and goods receipt, coded to the correct GL account, approved under policy and scheduled for payment.

Acceptance: It passes three-way match with no manual touch, and no reversal or duplicate payment within 60 days. 2% of invoices are audited monthly by the client's AP team.

Price: A fixed fee per accepted invoice. Exceptions routed to a human are not billable.

Dependencies: The client provides ERP read/write access, the vendor master and the approval matrix. Accuracy SLAs are suspended for any period when vendor master data is more than 30 days stale.

Warranty: Any accepted invoice later found to be a duplicate or mis-coded is credited at 3× the per-invoice fee.

Ramp: Months 1–2 in shadow mode (no fee, accuracy reported). Month 3 onward is billable once the audited accuracy rate passes the agreed threshold.

A finance leader can compare a price structured this way against the fully loaded cost of processing an invoice today, whether that work is done in-house or through a BPO. That is a comparison finance organizations are already equipped to make, in a way that a token count never allows.

The clause to watch is the dependency on vendor-master data. It reads like fine print, but it is where much of the risk sits, because the vendor only owns the outcome to the extent it controls the inputs. The more a result depends on the buyer's data, policies, and systems, the longer the assumptions section grows, and a long enough one quietly turns an outcome price back into a conditional one. The discipline is to keep that list short rather than letting it expand until "outcome pricing" is outcome pricing in name only.


What changes for buyers

  • Success has to be defined before the purchase. This is the most demanding part of the shift and the most valuable. Many organizations have never written down what a good resolution or a correctly processed invoice is, and outcome pricing requires them to.
  • Baselines become essential. A per-outcome price cannot be judged without knowing the current cost of producing that same outcome.
  • Budget moves from IT toward operations. Outcome-priced AI competes with labor and BPO spend rather than software licenses, which changes who signs the contract and how large it can be.
  • The buyer owns its dependencies. As with any SOW, if the data is poor or the policies unclear, the vendor will either price that risk in or write it out of scope.
  • Predictability is a real trade-off. Outcome pricing aligns spend with value, but it makes the monthly bill move with volume, which is harder to budget than a flat fee. Not every finance team wants that, and it is a legitimate reason to prefer a fixed price even when it is less aligned. The answer is the retainer-and-collars structure described below, which keeps spend inside a known band.

What changes for vendors

  • Inference becomes a cost of goods sold. Every failed attempt, loop, and oversized model call reduces the vendor's margin rather than the customer's budget, a direct incentive to engineer for efficiency.
  • Evaluation becomes part of the product. An outcome that cannot be measured reliably and transparently cannot be billed, so the evaluation harness becomes part of the contract.
  • Delivery starts to look like professional services. Defining outcomes, building integrations, and tuning the agent to a customer's policies resembles a services engagement, because it is one.
  • Pricing has to carry a risk premium. As with a fixed-fee SOW, the per-outcome price needs to cover the vendor's variance as well as its expected cost.

The difficult parts

1. Attribution. When revenue rises after a sales agent is deployed, it is rarely obvious how much of that increase the agent is responsible for. Outcomes that are easy to attribute, such as a ticket resolved with no human involvement, will move to outcome-based pricing first. More diffuse outcomes, such as improved retention, may never fully get there.

2. Goodhart's Law. Once a measure becomes a target, it tends to lose its value as a measure. An agent paid per resolution has an incentive to mark interactions as resolved, just as a coding tool paid per merged pull request has an incentive to merge, and a content tool paid per accepted draft has an incentive to satisfy whatever check stands in for quality rather than quality itself. The remedy is the same discipline a services firm relies on: acceptance has to be tied to something hard to fake, such as tests that must pass, a defect rate held under an agreed bar, or a human sign-off, backed by warranty terms and audits, so that nothing counts as done until it has genuinely met the criteria.

3. Slow outcomes. Some results, such as a customer not churning, can only be observed after 90 days or more. Contracts for this work need leading indicators billed provisionally and lagging indicators that settle the account, much as milestone payments carry a holdback.


The case against

Everything so far builds the case for outcome pricing. The honest problem is that the case against is not a list of implementation headaches to be engineered away; it is a set of structural arguments that hold even when both sides act in good faith.

The buyer does not stop paying for failure; it pays for failure averaged into the success price and marked up for risk. Metered pricing exposes that same cost directly, without the markup. Outcome pricing is not a way to avoid paying for failure; it is a way to buy insurance against it, and like any insurance it is priced to leave the insurer ahead.

The economics can unravel through adverse selection. A vendor quoting one outcome price must set it against an expected success rate blended across its customers. But success depends heavily on the buyer's environment, and buyers know their own environment better than the vendor does. The buyer with clean data and simple policies works out that it is subsidizing the messy ones and defects to usage pricing, where it pays only its own low cost. Its departure raises the average difficulty of the remaining pool, so the vendor has to raise the outcome price, which prompts the next-cleanest buyer to do the same arithmetic and leave. This is the same dynamic that destabilizes insurance markets, and there is no obvious reason outcome-priced AI is immune to it. The stable equilibrium may be that only the hardest environments stay on outcome pricing, at a price that reflects exactly that.

It can quietly raise the buyer's total cost, not lower it. A vendor paid per successful outcome has every incentive to win the easy cases and decline or escalate the hard ones, because the hard ones burn attempts without paying out. That is rational for the vendor and expensive for the buyer, because the easy, high-volume cases are the ones that used to carry the fixed cost of running the function at all. Strip them out and the buyer is left staffing a shrunken, almost entirely difficult caseload at the same overhead. The pattern is not unique to support: a coding tool that generates the boilerplate endpoints but escalates the thorny concurrency bug, or a content tool that drafts the easy product pages but declines the regulated ones, leaves the buyer's own people holding the hardest work. The per-outcome invoice can look like a saving while the blended cost of the whole function rises, and anyone comparing it to a historical average unit cost, rather than to the cost of the cases the vendor actually takes, will miss this.

None of this proves outcome pricing wrong, and I still think it wins where outcomes are discrete, high-volume, and genuinely hard to deliver. But these are not objections that better tooling clears away. They are reasons the opposing choice is rational, reasons it will persist across a large part of the market, and reasons that anyone presenting outcome pricing as the obvious destination is overselling a question the industry has not actually settled.


The likely end state: a retainer plus success fees

Most mature services relationships are not purely fixed-fee. They combine a retainer, which is a guaranteed base that covers the vendor's fixed costs, with success fees that vary according to results, and they use caps and floors so that neither party carries unlimited risk.

Enterprise AI pricing is likely to settle in a similar place:

  • Platform fee: covers integration, governance, observability, and the evaluation harness
  • Per-outcome fee: the main variable component, tied to accepted outcomes
  • Collars: a minimum commitment that gives the vendor predictability and a ceiling that gives the buyer budget certainty
  • Quality multipliers: higher rates for outcomes that exceed the agreed SLA, and credits when an accepted outcome is later reversed

This structure also answers the sharpest objection in the case against, which is selection. The fix is to define the outcome over a whole population of work rather than item by item, the full support queue, the entire sprint backlog, or the whole content batch, so the vendor is paid on the share it gets through rather than on items it hand-picked. Priced that way it cannot take the easy ones and leave a residue of hard ones, because the hard cases sit inside the same denominator it is measured on. The same scoping blunts adverse selection: a buyer with a clean environment negotiates against its own mix rather than a pool average, so it has less reason to defect, and the incentive the model exists to create, getting through the entire body of work rather than only the parts that pay out, stays intact. It does not make the objections disappear, but it shows they are a function of how the outcome is scoped, not an inherent flaw in paying for results.

The contract shape is not new; it is close to how a well-run managed services or BPO engagement has always operated. What is new is that the capacity delivering the work is mostly software, and that single change has consequences the old model did not. Margins are no longer bounded by headcount, so a vendor that solves an outcome cheaply can serve far more volume than a staffed firm could. Ramp is measured in weeks of integration rather than hiring and training. And because the spend competes with labor and BPO budgets rather than software licenses, the buyer who owns it often sits in operations, not IT. The familiar contract is being pointed at a cost base that behaves very differently, and that is the part worth paying attention to.


Where this is heading

Tokens matter a great deal to the companies that supply AI, much as kilowatt-hours matter to a power utility. They matter far less to the organization buying the result, which cares about what gets produced, not how much compute was consumed along the way.

The shift from cost per token to cost per task shows that the industry already senses this. Pricing by outcome, and recording that outcome in something that resembles a Statement of Work, is the point at which enterprise AI stops being a technology purchase and becomes a delivery commitment. That shift will not reach every workflow, and it will arrive first where a result is easy to define, cheap to verify, clearly attributable, and high enough in volume to justify the cost of contracting for it, while a long tail of judgment-heavy or low-volume work stays on seats or tokens for good reason. The organizations best placed to take advantage of it will be the ones that can state clearly, and in advance, what a finished piece of work actually looks like.


So where do you land? If you are the buyer, would you rather pay for what the AI does or for what it delivers, and what would it take to move you off the model you use today? I don't think there is one correct answer here, which is exactly why I want to know which way you lean, and why.


Sources

Top comments (0)