AI Engineer World's Fair 2025
Revenue Engineering: How to Price (and Reprice) Your AI Product
Loading slides…
Read the talk
Revenue Engineering: How to Price and Reprice an AI Product
Agent pricing connects opaque work to a visible bill. Choosing the right unit means understanding the buyer, the architecture, and how both change as the product improves.
From a talk by Kshitij Grover
What should an agent charge for?
When an agent does work on your behalf, what should determine the bill? Pricing is a form of product friction: it can establish that the product delivers something worth paying for, or prevent someone from discovering that value at all. Where to introduce that friction depends on the audience, the value delivered, and how the product is evolving. Kshitij Grover approaches this problem as a co-founder of Orb, which provides usage-based billing infrastructure across layers of the software stack. In its customer conversations, deciding how to monetize increasingly comes before deciding how to implement billing.
Replit Agent makes the problem concrete. Grover opens with a post from Replit founder and CEO Amjad Masad; Replit is an Orb customer. An agent that builds full-stack web applications could charge a fixed amount whenever it creates a checkpoint, or vary the charge with the complexity of the change. The post contrasts a simple UI change with a large refactor. A checkpoint is an understandable unit, but it does not necessarily represent a consistent amount of work.
Choosing between those approaches requires knowing who uses Replit and what costs Replit incurs. It also requires considering the moment the user sees the charge. Someone supplies an initial prompt, but may have little visibility into or control over the subsequent work. A bill presented only after completion can therefore surprise them. That opacity is especially pronounced with agents, although the same pricing questions reach down into AI infrastructure.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From licenses to variable AI costs
Software pricing has moved from buying a fixed TurboTax license at Fry’s Electronics to subscriptions, usage charges, and potentially charges for outcomes.
| Model | What the customer buys |
|---|---|
| Fixed license | Access to a software product |
| Seat subscription | Access for each licensed user |
| Usage-based pricing | Metered consumption |
| Outcome-based pricing | A defined result |
Grover uses a $30-per-seat subscription as an illustration of the familiar middle step. Across these models, traditional pricing aims to remain simple enough to understand, introduce willingness to pay as a signal of value, and protect margins.
Grover cites 80% as a healthy traditional software margin. Infrastructure and AI make margins more variable, though not necessarily unhealthy: an agent can encounter extreme workloads that create disproportionate costs. Predictability consequently matters on both sides of the transaction. A mature customer needs to budget not just for one developer, but for how spending will scale through adoption across the company.
Early AI products face another constraint: buyers may not yet understand what the product can do. They need to experiment and see proof before committing money. Moving the payment decision later can help establish that proof, even while the provider incurs variable costs of goods sold, or COGS. Those costs also move quickly. Grover uses an unspecified OpenAI model-cost cut of one-third overnight to illustrate how abruptly an agent’s underlying economics can change. The point is the speed of change, rather than a stable cost assumption on which to build a pricing model.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Price for the buying journey
Three considerations organize the pricing decision: audience and value delivery, margin structure, and flexibility to experiment. Margin structure means understanding the axes along which costs scale, rather than optimizing only the literal margin on day one. That distinction matters particularly for an early product whose underlying costs are changing rapidly. Flexibility matters because the first pricing model is unlikely to be the final one.
Audience determines what a sensible purchasing experience looks like. ServiceNow’s contact-sales pricing page can seem unnecessarily obstructive to a developer, yet fit an enterprise buyer with an existing commitment and an opportunity to buy additional products. The conversation with sales helps tailor the purchase to that relationship. An individual developer, by contrast, may have no procurement team or formal purchasing process and expect to start trying the product immediately.
Look beyond whoever first opens the pricing page. Can that person introduce a vendor on day one, or does adoption require a cross-functional decision? What do they need to establish first? If the immediate need is proof that the product works, provide that proof before inserting a pricing decision. The right amount of friction depends on the buyer’s next step.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Packaging tells customers how to use the product
Replit’s pricing page makes its tiers transparent and offers a free entry point, letting users discover value before thinking hard about payment. The package then communicates the intended use: which models are available, how many agent checkpoints are included, and how many seats come with the plan. Those choices suggest whether the product is collaborative or individual, and whether it belongs in a daily workflow or occasional use. They shape user incentives while controlling the provider’s backend costs.
Unify, aimed at revenue and go-to-market teams, provides a different example. Grover asks the audience to notice its higher displayed price before considering whether the charge is monthly or annual: the price itself communicates positioning. In the historical page he discusses, the two higher tiers have custom pricing. The displayed allowances are 50,000, 200,000, and 600,000 credits; Grover explicitly says he does not know what those credits mean. Their apparent scale nevertheless conveys something about the workflows the product expects to support. These are the talk’s historical allowances, not the current page’s packaging.
Customer logos complete that positioning. Developer brands and Fortune 100 enterprises signal different intended buyers. The pricing experience is larger than the price point: tiers, allowances, access paths, and customer references together tell visitors whether the product is meant for them.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Turn architectural advantages into pricing advantages
As a product’s architecture changes, its margins change with it. That creates an opportunity to pass engineering improvements through to customers in the pricing model. Cloudflare Workers illustrates the connection: its isolate-based architecture supports charging for CPU milliseconds. When an agent calls OpenAI or Anthropic and waits for a response, that idle network time does not consume billable Workers CPU time. External model-provider charges and other applicable service fees still apply.
The distinction matters for agents because elapsed time can include substantial waiting on external services.
| Meter | Treatment of an external API wait |
|---|---|
| CPU time | Idle waiting does not consume CPU time |
| Wall time | Waiting remains part of elapsed duration |
An architectural decision therefore becomes a customer-facing advantage for this workload. Grover treats this as a way to pass technical innovation to users through pricing.
Protecting margins does not require charging proportionally for every increment of usage. First identify the extreme workloads that could create unacceptable exposure; then consider how to prevent them or encourage reasonable usage. Rate limits and guardrails can protect the business without forcing the customer to experience a continuously rising bill for every action.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Remove credit counting from the workflow
Jasper’s Brand Voice and Unlimited Credits announcement connects architecture to a different kind of customer benefit. Grover presents it as a historical example and notes that the post and pricing may have changed since he collected them. Marketing teams writing copy do not want to count credits. Jasper’s architecture could switch between models under the hood, removing the need for users to choose the right model for each job. In the example, Jasper moved to unlimited credits across all three tiers.
That packaging supports the product’s intended role as a routine part of marketing work. A customer who fears running out of credits must decide which tasks deserve Jasper; a customer without that recurring decision can use it throughout the workflow. The architectural advantage and the pricing model reinforce the same value proposition, without requiring the user to manage the underlying model choices.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Repricing changes the organization too
Product teams continuously invest in R&D, but traditional seat pricing often captures that added value only periodically. Grover illustrates the mismatch with an annual increase from $20 to $25 per seat. An agent can make incremental value more visible: users take an action, receive an output, and see the quality improve. That closer connection between action and result can make an evolving price easier to understand.
Grover reports that some customers change prices two or three times a month. That cadence creates work beyond editing a price table. Customers must understand the changes, and the business must manage the resulting complexity in their expectations.
Internal incentives also need to follow the pricing model. A commissioned sales team selling large enterprise contracts operates differently from one supporting pay-as-you-go adoption. Grover describes usage-based companies that commission representatives on account expansion over time rather than the initial contract alone. That shifts attention toward what happens after the sale, raising a further question: how should sales and customer success divide responsibility for growing the account? Repricing can change the organization as well as the bill.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Simulate the bill before changing the price
Before applying a new pricing model, simulate its effect on customer usage. At meaningful operating scale, an aggregate revenue estimate is insufficient: customers with different use cases can respond very differently to the same charging rule.
- Group customers into cohorts with distinct usage patterns.
- Calculate what those patterns would cost under the proposed model.
- Inspect how the revenue mix changes across cohorts.
- Examine the highest-revenue customer individually to understand its exposure.
This makes repricing a decision informed by observed customer behavior.
A small TypeScript calculation makes that comparison concrete. Here, constructed usage records compare a fixed checkpoint charge with a proposed complexity-weighted charge. The rates and complexity values are teaching inputs, not Replit’s pricing. Both calculations use the same usage records; the proposal changes only the charging rule.
typescript
type Usage = {
customer: string;
cohort: string;
checkpoints: number;
complexityUnits: number;
};
const usage: Usage[] = [
{ customer: "a", cohort: "small-edits", checkpoints: 100, complexityUnits: 120 },
{ customer: "b", cohort: "large-changes", checkpoints: 40, complexityUnits: 240 },
];
const currentBill = (u: Usage) => u.checkpoints * 20;
const proposedBill = (u: Usage) => u.complexityUnits * 10;
const comparison = usage.map(u => ({
...u,
currentCents: currentBill(u),
proposedCents: proposedBill(u),
deltaCents: proposedBill(u) - currentBill(u),
}));
const cohorts = [...new Set(usage.map(u => u.cohort))].map(cohort => {
const rows = comparison.filter(row => row.cohort === cohort);
return {
cohort,
currentCents: rows.reduce((sum, row) => sum + row.currentCents, 0),
proposedCents: rows.reduce((sum, row) => sum + row.proposedCents, 0),
};
});
const topCurrentCustomer = [...comparison]
.sort((a, b) => b.currentCents - a.currentCents)[0];
console.table(comparison);
console.table(cohorts);
console.log({ topCurrentCustomer });
The comparison separates customer impact from total revenue impact. It estimates bills under unchanged usage; it does not predict how customers would alter their behavior after repricing.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From unlimited plans to choosing a spending plan
Grover closes with predictions for AI agent pricing in 2025. He expects continuing price competition and cheaper agents to push providers toward effectively unlimited plans. Those plans would still have caps and guardrails, but their aim would be to make agents habitual participants in every workflow rather than tools customers reserve for selected tasks.
He also expects outcome-based pricing, already used by some companies, to become more concrete. Its difficult part is defining the service-level agreement, or SLA: what counts as the outcome, how it is measured, and whether that definition makes sense to the customer. Charging for success requires contracts precise enough that both parties can recognize success when it occurs.
The final prediction returns to the opening problem of an opaque agent producing a surprising bill. Real-time spending visibility, balance alerts, and spend management could give users more control. Grover compares a possible agent experience to a database query planner: before executing a prompt, the agent could estimate consumption or offer alternative execution plans. His hypothetical includes three options, with illustrative estimates of 10,000 and 4,000 credits for two of them. Those are proposed costs before execution, not measured consumption. He expects this kind of customer control to become more sophisticated within the year of the talk.
For further tactical detail, Grover points to Orb’s Pricing AI Agents e-book, listed in its e-book catalog, and names threshold billing, fraud, and prepaid pricing models as topics to explore there. Those implementation concerns sit beyond this talk’s central design problem: helping customers understand and control what they will pay as agents do more work on their behalf.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Jasper's historical announcement explains its three paid tiers, removal of credit limits and automatic model selection.
Further reading
- Workers pricing and idle I/OArticle
Cloudflare explains CPU-time billing and why waiting for network responses does not consume billable CPU time.
Updates since the talk
The June 2025 announcement explains the transition from fixed-price checkpoints to charges reflecting task effort.
Full transcript
Loading transcript…