Usage Billing Review

Custom Contract Pricing for Enterprise SaaS Accounts

AI-driven SaaS forces vendors to abandon seat-based pricing for consumption models.

· 11 min read · Updated
Cover illustration for “Custom Contract Pricing for Enterprise SaaS Accounts”
Enterprise Billing and Contract Overrides · August 14, 2026 · 11 min read · 2,440 words

The enterprise SaaS contract is being redrawn starting from how it prices work rather than how it describes features. The seat-based model is failing as the default unit of value because it cannot capture what AI-era software actually delivers: work performed, tokens consumed, outcomes achieved, none of which scale the way a per-user license does. That mismatch has opened a pricing gap between what vendors charge and what their systems actually cost to run, and closing that gap is forcing changes to the contract itself, not just the number on the invoice.

The arithmetic is straightforward: the 2026 State of B2B Monetization report documents that even as token prices fell sharply year-over-year, total AI-driven spending grew dramatically, so flat-fee contracts are under-capturing value at scale while the vendors selling them absorb rising per-call GPU costs with no relief built into the price. L.E.K. Consulting's B2B SaaS Pricing team has reached the same conclusion from the cost side: rising compute and data costs have exposed the limits of flat or seat-based pricing that was never built to reflect what it actually costs to serve each customer. That makes this a margin-protection problem for vendors, not a growth experiment they can take or leave.

The shift is already visible across large vendors making concrete moves. GitHub has moved Copilot to AI Credits tied to token consumption, Anthropic has lowered Enterprise seat prices while pushing toward usage-based pricing, SAP has announced AI consumption pricing, Adobe has introduced Firefly credit-based pricing for AI-generated images and effects, and HubSpot has announced outcome-based pricing for its Breeze AI agents. None of these are marketing adjustments. Each one shows a vendor rebuilding how it bills around what its AI systems actually cost to run and what they actually deliver.

The direction of travel is set at the industry level, too. BetterCloud's SaaS industry analysis cites Gartner's projection that by 2030, a significant share of enterprise SaaS spend will shift to usage-, agent-, or outcome-based pricing, and that by 2027, most top SaaS vendors will offer consumption-based pricing for at least part of their portfolio. What's being rebuilt is an architectural problem, not a price list.

What hybrid pricing means in a custom enterprise contract

A hybrid enterprise contract holds a committed baseline, a variable consumption layer, and optionally an outcome tier, all on one contractual and billing foundation at the same time. That is a different thing from a subscription with usage charges tacked on after the fact.

The committed baseline, the floor, gives the buyer budgeting predictability, and it gives the seller revenue confidence before any usage happens. It is the design constraint that makes the variable layer workable for both sides, not an obstacle to pricing that way. On top of that floor sits the usage or consumption layer: metered charges for tokens, API calls, GPU-minutes, or agent actions that accumulate as the customer actually uses the product. Some contracts add a third, optional layer tied to delivered outcomes rather than activity, such as resolved tickets, successful chargeback recoveries, or qualified leads, the model HubSpot's Breeze AI agents and Zendesk's per-resolution pricing both demonstrate.

Credit-based structures specifically are proliferating: the same report tracks companies in the PricingSaaS 500 Index offering credit models, up more than double year-over-year, with Figma, HubSpot, and Salesforce all introducing credit-based components in 2025. A credit model lets a buyer prepay into a wallet and draw it down against whatever mix of consumption the contract defines, and it pairs naturally with a committed floor: the credit purchase often is the commitment.

Building this correctly means the contract and the billing system have to agree, line for line, on four mechanics operating together: the size and term of the committed spend, the metering logic for usage once that floor is crossed, the definition and verification method for any outcome tier, and the reconciliation between prepaid credits drawn down against consumption and postpaid overage invoiced separately. None of these four can be designed in isolation. A floor set without reference to expected usage either overcharges customers for capacity they will not touch or leaves the vendor exposed the moment usage exceeds it. If an outcome tier is defined without a metering system that can verify the outcome, nobody can actually bill against that clause.

Why getting the commitment structure wrong creates reconciliation debt

A commitment structure where the floor, the overage logic, and the usage measurement do not agree does not fail at the signing table. It fails every month at invoice time, and the failure compounds as the account grows, because each new usage pattern the customer adopts creates another case the original structure never anticipated.

The evidence of how this plays out for buyers is direct. Zylo's SaaS Management Index finds that most IT leaders encountered price increases at SaaS renewal in the past year, and 61% were forced to cut projects or initiatives because of unplanned SaaS cost increases. Much of that volatility traces back to usage-based charges, which appear outside the budgeting cycles finance teams built around predictable seat counts. A customer who signed on the assumption of stable monthly costs finds out, three months in, that agent actions or token consumption have pushed the bill somewhere nobody modeled.

The accounting layer adds a second source of strain. Usage-based and hybrid contracts create variable consideration that has to be estimated at contract inception, constrained, and then updated every reporting period, which is a hard requirement under the relevant accounting standard, not a best practice a finance team can skip. When contracts layer upgrades, downgrades, add-ons, and usage charges on top of a committed base, they force recalculations mid-stream that break spreadsheets and manual processes built for simpler subscription math. The deeper mechanics of that accounting burden get fuller treatment later in this piece, but the short version is that a badly designed commitment layer does not just confuse customers. So finance has to redo that work by hand, period after period.

Every decision made when the contract is drafted, how the commitment is defined, when overages trigger, how usage gets metered, how credits apply against consumption, either produces a clean invoice automatically or produces a task someone has to perform manually every billing cycle. There is no third option. A vendor that treats the commitment structure as boilerplate, copied from a prior deal and lightly edited, is choosing the second path without realizing it, and the choice appears first as a support ticket and then as reconciliation debt.

What metering infrastructure must do for a custom contract

A custom enterprise contract with any usage component is only as accurate as the metering layer underneath it, and most teams do not find out how demanding that requirement is until the first invoice dispute lands on someone's desk.

AI products make this harder than prior generations of usage-based software because they turn every token, every tool call, and every agent action into a billable event. A company running several million such events per month, and growing at several times that rate annually, needs metering infrastructure built for the order of magnitude it is heading toward, not the one it currently runs at; that is a principle the 2026 State of B2B Monetization report's infrastructure commentary lays out directly. Infrastructure sized for current volume becomes the bottleneck, and it breaks the contract's economics within a year of signing.

The design principle that practitioners converge on is to treat usage events the way a bank treats financial transactions: immutable once recorded, idempotent so the same event is never double-counted, traceable back to its source, and aggregated close to real time rather than batched overnight. Pipelines built this way need to tolerate faults and still be able to backfill missing data without corrupting invoices already issued. So that rules out a lot of lightweight logging setups: they work fine for internal analytics, but they were never built to survive a billing dispute.

Usage collection and processing have to be decoupled from the core application, typically through a message queue or a dedicated ingestion service, so that a usage spike or a billing system problem does not take down the product customers are paying to use. Conflating these concerns, metering, entitlement enforcement, and billing, into a single system is the design error that creates the invoice disputes described in the previous section. They are three distinct jobs. Metering records what happened. Entitlement enforcement checks consumption against a cap in real time, and it gates or alerts before the limit is breached. Billing turns recorded usage into an invoice line after the fact. A team building on general-purpose payment infrastructure needs to be cautious here: a payment processor's meter event summaries exist for billing purposes only, and a vendor still needs its own internal records, separate from the processor, for debugging, for audits, and for showing customers their usage in anything close to real time. So the billing tool cannot double as the system of record for metering truth.

What the metering layer has to expose to the contract layer comes down to three things. It has to track commitment drawdown: it knows at any moment how much of the committed minimum has been consumed, how much remains, and when overage logic should activate. It has to enforce entitlements, gating or alerting as consumption nears a cap, a function distinct from the billing system that invoices for usage once the cap is already crossed. And it has to produce an audit trail detailed enough that every event can be traced back to a specific action at a specific time when a customer disputes a charge.

How the pricing dimensions of an AI contract interact

If a contract charges across tokens, GPU-minutes, agent actions, and outcome metrics at the same time, you cannot configure it once and leave it alone. It's a modeling exercise, because these dimensions interact with each other, and pricing them as though they were independent is a reliable way to erode margin or end up in a dispute with the customer.

L.E.K. Consulting's analysis finds that traditional feature tiers rarely hold up once AI capabilities span multiple functions or create different value for different customers, and vendors moving toward modular packaging have to make sure the pricing of each module stays coherent with every other module at the contract level. A module priced in isolation, without reference to how customers actually combine it with the rest of the product, tends to either cannibalize a higher-value module or price itself out of the deal.

The outcome-based dimension is the least mature piece of this system and demands the most explicit language in the contract. HubSpot's Breeze AI agent pricing and Zendesk's per-resolution model are among the earliest public examples of outcome pricing in production, and any contract built on this model has to spell out precisely what counts as a qualifying outcome and what happens when the customer disputes whether one occurred. Billing infrastructure built for value-based pricing of this kind has to be able to attach arbitrary outcome metrics to an invoice, not just count tokens, and most general-purpose billing platforms were never built to do that. A platform that can only count units of consumption cannot bill against a resolved ticket or a recovered chargeback, because those are judgments about results, not counts of activity.

This is the gap that purpose-built infrastructure for AI-era contracts is meant to close: the ability to model and then execute any combination of committed floor, metered consumption, and outcome tier within a single engine, rather than forcing a vendor to stitch together a subscription platform, a usage metering tool, and a manual outcome-verification process. The architecture only pays off if the modeling happens before the contract is signed. The vendor's pricing team needs to project the customer's likely consumption across every active pricing dimension under three scenarios, low, expected, and high, and confirm that the committed floor, the variable layer, and the outcome tier produce a margin-positive result in each one. A contract signed without that modeling is a guess dressed up as a negotiated deal.

Revenue recognition under ASC 606 when a contract has all three layers

A contract combining a committed floor, a usage layer, and an outcome tier raises more than operational questions. It creates direct accounting obligations that have to be satisfied every reporting period, and those obligations function as constraints on how the contract can be designed in the first place, not as paperwork to handle after the deal closes.

Usage-based and consumption pricing create variable consideration that must be estimated at contract inception, constrained for uncertainty, and updated each reporting period as actual usage comes in, so for a deal combining a fixed subscription fee with variable API usage, the total transaction price has to be split between the fixed and variable pieces and recalculated as consumption accumulates over the life of the contract. A finance team working from static spreadsheets can do this once. Doing it correctly every quarter, across a book of hundreds of custom contracts each with its own floor and its own usage pattern, is a different kind of problem, and it is the reason the metering and modeling work described earlier in this piece has to feed directly into revenue recognition rather than operate as a separate system.

The most common place this breaks down is in how performance obligations get bundled. Implementation services priced at zero dollars inside a deal do not disappear as a distinct performance obligation just because the invoice shows no charge for them, since the accounting has to follow the underlying economics of the deal rather than how it is presented on paper. If implementation is genuinely distinct from the ongoing subscription, its revenue cannot be recognized ratably alongside the subscription revenue, even when the contract bundles them into one line for the customer's convenience. Get this wrong, and you recognize revenue too early, too evenly, or in the wrong period entirely, any of which draws scrutiny in an audit.

The authoritative guidance on all of this was most recently updated by KPMG, which issued a revised revenue recognition handbook in December 2025 covering new interpretations on share-based noncash consideration, share-based consideration payable to a customer, and related topics, and that handbook is the current baseline against which compliance gets measured. A hybrid contract with a committed floor, a consumption layer, and an outcome tier sits squarely inside the territory that guidance addresses. Designing the pricing architecture without a finance team in the room from the start all but guarantees the contract will need to be re-papered the first time an auditor asks how the variable consideration was constrained.

More in Enterprise Billing and Contract Overrides