How to Price an AI Agent: Per-Call vs Outcome-Based Billing

← All posts

Most AI agents are priced per call — count the calls, multiply by a rate, send the invoice. The problem is that customers don't care about calls. They care about results. A call that books a $50,000 meeting and a call that hallucinates an empty answer carry wildly different value, yet per-call pricing charges the same flat amount for both. Outcome-based billing flips that: the customer pays for wins, not attempts. Here's how the two models compare, when each one wins, and how to instrument the outcome-based pattern with Rev's telemetry SDK.

Why per-call pricing misaligns incentives

Per-call is the default in agent billing because it's the easiest to invoice. "500 calls at $0.05, that's $25" is a sentence any buyer understands. But that simplicity hides three structural problems that compound at scale, where they wound you the most:

Wins and losses cost the same. A converting outreach run is worth hundreds of dollars to the customer — one that bounces is worth nothing. Per-call pricing charges the same flat rate for both, regardless of how much value the agent actually delivered.
No commercial incentive to improve quality. If revenue is decoupled from outcomes, the vendor has no financial reason to ship a better model. Model R&D gets deprioritized because better accuracy doesn't move the top line.
Trust erodes at volume. "I paid for 10,000 calls and only 200 actually worked" is a churn-inducing conversation. Customers see activity on the invoice, not value — and they remember the gap at renewal.

Per-call pricing at scale: three failure modes

Push per-call pricing past a few hundred runs per customer and the cracks widen into structural failure modes:

Underpricing your successes. A 1% conversion on 10,000 calls means 100 wins — but the customer pays the same flat rate they would pay at 100% conversion. Your revenue from those wins is capped at the per-call amount, regardless of the value delivered.
Overpricing light users. New customers evaluating with 50 calls see a token-sized bill that doesn't justify a credit card on file. The price-to-value gap kills activation and bleeds trial conversions.
Noisy renewals. Long-tenured customers get quotes tied to call volume — a number that grows even when value capture doesn't, because the invoice tells the wrong story.

How outcome-based billing works mechanically

Outcome-based billing inverts the relationship. You register an agent run as pending with an expires_at window — typically seven days. The customer pays the base fee and the token component immediately. When the outcome is detected (a reply arrives, a meeting is booked, a ticket is resolved), you resolve it and the outcome bonus is charged. If the window expires without resolution, only the base and token fees are billed.

Rev implements this natively through a three-component pricing stack:

Base fee — a small flat amount per call (covers your fixed overhead so you're never underwater on a run)
Token rate — per-token charge (covers the variable LLM compute cost)
Outcome bonus — charged only when the outcome resolves to success (captures the value when the customer wins)

You set each component independently per pricing tier in the dashboard. Set any component to zero if it doesn't apply to your model. The pricing engine computes the right amount at meter time and stores it immutably with the event — your historical prices don't shift when you later change your tier config.

Per-call vs outcome-based: which fits your agent?

Factor	Per-Call	Outcome-Based
Incentive alignment	Neutral — the vendor earns the same on wins and misses	Aligned — the vendor earns only when the customer wins
Customer clarity	High — "500 calls at $0.05" is obvious to anyone	High — "100 outcomes at $5.00" is just as obvious
Revenue per success	Capped at the per-call rate, regardless of outcome value	Scales with the customer's value capture on each success
Underpricing risk	High — wins priced identically to misses	Low — bonus calibrates to the value delivered
Implementation effort	Lowest — meter calls, multiply by a rate	Medium — requires reliable, programmatic outcome detection

Per-call works when every call is uniform in compute cost, in success rate, and in customer value. The moment any of those break — high-value actions, low-and-variable conversion, wide token spread — outcome-based, or the hybrid stack, pulls ahead on margin, on customer trust, and on churn.

Instrument outcome-based billing with Rev's SDK

The mechanics in code: register the agent run as pending when it fires, then call /v1/outcomes/:id/resolve once detection confirms whether it succeeded.

Track task success with Rev SDK javascript

// Step 1: agent fires — meter as pending, outcome bonus NOT charged yet
const meterResponse = await fetch('https://rev.polsia.app/v1/meter', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.REV_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    agent_id: 'outreach-agent-v2',
    action: 'email.sent',
    tokens_input: 1400,
    tokens_output: 380,
    outcome: 'pending',
    expires_at: new Date(Date.now() + 7 * 86400000).toISOString(),
    metadata: { prospect: 'vp-eng@acme.com', campaign: 'q2-outreach' },
  }),
});
const { outcome_id, price_charged } = await meterResponse.json();
// price_charged so far = base_fee + token_fee only

// Step 2: prospect replies three days later — resolve the outcome
await fetch(`https://rev.polsia.app/v1/outcomes/${outcome_id}/resolve`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.REV_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    outcome: 'success',
    metadata: { reply_type: 'positive', meeting_booked: true },
  }),
});
// NOW the outcome bonus is charged against your pricing tier

If the seven-day window expires without a resolve call, Rev charges only the base fee and the token component. The same fallback applies on outcome: 'failure' — the bonus lands only at resolution, and only on success. That asymmetry is what makes outcome-based billing safe to ship: you never get paid for an outcome you didn't actually deliver.

Revenue impact: Compare two pricing models for an AI SDR agent that fires 10,000 outreach calls per month at a 3% meeting rate (300 meetings booked). Per-call flat at $0.05/yield yields $500/month total — the same number whether the agent converts at 0% or 10%. Outcome-based at $0.01 base per call + a $5.00 meeting bonus yields $100 base + $1,500 in outcome bonuses = $1,600/month — three times the per-call revenue, with the upside scaling linearly as the customer's success increases. And customers agree happily to that math, because they're paying a small fraction of the value they receive on each booking.

Bottom line

Outcome-based pricing wins when outcomes are detectable and binary. Per-call wins — and is easier to ship — when every call is uniform and value variance is low. For most production AI agents in sales, support, and lead generation, the hybrid stack (base plus token plus outcome bonus) covers both your cost floor and your upside without forcing customers to pay for misses.

Ready to price on outcomes?
Get your API key and instrument your first outcome-based agent in under 5 minutes. Base, token, and outcome components — one endpoint. Try Rev Free →