For the last 15 years (the "SaaS 1.0" era), the Golden Rule of monetization was simple: charge for the Seat.

• Salesforce charges ~$150 per user per month.

• Slack charges ~$12 per user per month.

• Jira charges ~$7 per user per month.

It was predictable, scalable, and easy to sell to a CFO ("We have 50 employees, so we need 50 seats").

AI breaks this model completely.

The "Heavy User" Problem:

In traditional SaaS, the marginal cost of a user is effectively $0. (A row in a Postgres database).

In AI-Native SaaS, the marginal cost of a user is highly variable (Compute/Tokens).

• User A: Logins in once, asks 1 question. Cost to you: $0.01.

• User B: Uses your tool to summarize 500 legal contracts a day. Uses GPT-4-32k. Cost to you: $50.00.

If you charge both users a flat $20/month, User B is destroying your margins. You are subsidizing your power users with your churned users. That is a recipe for bankruptcy.

Part 1: The "Token" or "Credit" Wallet

The immediate solution (SaaS 2.0) is to expose the cost structure to the user via "Credits."

Companies like Midjourney, Jasper, and OpenAI have popularized this pattern.

The Wallet Pattern:

Plan: Pro ($50/month) includes 5,000 Fast Credits.

• Text Generation = 1 Credit.

• Image Generation = 10 Credits.

• Video Generation = 100 Credits.

Top-Ups: If you run out, you buy a "Top-Up Pack" ($20 for 1,000 credits).

This protects your downside. If a user goes viral or automates a massive workflow, they just buy more credits. Revenue scales linearly with Cost (COGS).

Part 2: Outcome-Based Pricing (The Holy Grail)

The problem with Credits is that they are untransparent to the buyer. Customers hate counting tokens. They don't know what a "token" is. They want Work done.

The innovative companies are moving to Outcome-Based Pricing.

Case Study: Intercom Fin

Intercom launched an AI Support Agent called "Fin."

They do not charge per month. They do not charge per token.

They charge $0.99 per Resolved Ticket.

• If the AI talks to the customer but gives up and hands over to a human: Cost is $0.00.

• If the AI solves the problem completely and the customer leaves happy: Cost is $0.99.

This aligns incentives perfectly. The customer only pays for value. Intercom is incentivized to make the AI smarter.

Part 3: The "Work" Metric

As we move from "Copilots" (which help you type) to "Agents" (which do the work), pricing will shift to "Work Units."

This allows AI companies to capture a portion of the Labor Market, not just the Software Market. The TAM (Total Addressable Market) expands from $500 Billion (Software) to $50 Trillion (Global Wages).

Part 4: Technical Implementation (The Metering Layer)

How do you actually build this? You cannot use Stripe Subscriptions out of the box. Stripe is designed for flat recursive billing ("Charge $20 every 1st of the month").

You need SaaS Metering Infrastructure.

Tools like Metronome, Orb, and Lago act as the "ledger" for usage.

JavaScript

// Every time the AI runs, your backend emits an event to the Metering Provider
await meteringClient.ingest({
  customer_id: "cust_123",
  event_name: "ai_generation",
  properties: {
    model: "gpt-4",
    tokens_input: 500,
    tokens_output: 200,
    status: "success",
    value_delivered: true
  }
});

At the end of the month, the Metering Provider aggregates these millions of events ("User A used 14,000 tokens and resolved 4 tickets") and tells Stripe what to charge.

Part 5: The Pitfalls of Usage-Based Pricing

It sounds perfect, but it is dangerous. If you get it wrong, you will destroy your revenue predictability.

Pitfall 1: The "Taxi Meter" Anxiety

Problem: Users are afraid to click the button because they don't know if it will cost $0.01 or $10.00. This usage friction kills adoption.

Solution: Tiered Abstraction. Put the first 500 units in a flat subscription ($20/month). Only charge overage. This gives peace of mind + upside.

Pitfall 2: Revenue Volatility

Problem: In December, everyone goes on holiday. Your usage (and revenue) drops by 40%. Investors hate this.

Solution: "Use-it-or-lose-it" Annual Contracts. "Pay $50k upfront for 1M credits." You get the cash now; they get the flexibility.

Part 6: Full Integration (Stripe + Metronome)

Here is what the backend code actually looks like for a real Metered Billing implementation.

JavaScript

// Step 1: Subscribe user to a "Zero Cost" base plan in Stripe
const subscription = await stripe.subscriptions.create({
  customer: customerId,
  items: [{ price: 'price_metered_base_plan' }],
});

// Step 2: Ingest usage events (Real-time)
// This happens 10,000 times a day
await meteringClient.ingestEvent({
  customerId: customerId,
  eventName: 'gpt4_token_usage',
  timestamp: Date.now(),
  properties: { tokens: 1540 }
});

// Step 3: End of Month Sync
// specialized tools like Orb/Metronome handle this.
// They aggregate the 10k events into one number (Total: 4.5M tokens)
// And send it to Stripe Invoice Item.
await stripe.invoiceItems.create({
  customer: customerId,
  price: 'price_per_token',
  quantity: 4500000
});

Appendix A: The SaaS Metrics Glossary (AI Edition)

• ARPU (Average Revenue Per User): The north star metric. In AI, this should grow over time as users trust the AI more. If ARPU is flat, your AI isn't useful.

• Burn Multiple: How much cash you burn to generate $1 of ARR. AI companies have high Burn Multiples due to GPU costs. 2x is good. 5x is bad.

• COGS (Cost of Goods Sold): The API bill. OpenAI takes 30-50% of your revenue if you aren't careful. The goal is to get COGS under 20% by using smaller models (LLaMA-3-8B) for simple tasks.

• Gross Margin: Revenue minus COGS. Traditional SaaS has 85% margins. AI SaaS often has 50% margins. Wall Street penalizes this.

• NDR (Net Dollar Retention): Do your existing customers spend more next year? With Usage-Based pricing, NDR should be 120%+. If they use it more, they pay more automatically.

• Take Rate: The percentage of value you capture. If your AI generates $1000 of legal work, charging $10 is a 1% take rate. Charging $100 is a 10% take rate.

Appendix B: Frequently Asked Questions

Q: Should I build my own billing engine?

A: Absolutely not. Metering is harder than you think. Handling deduplication, late events, and timezone logic is a nightmare. Use Orb, Metronome, or plain Stripe Metering.

Q: Can I just charge a flat fee forever?

A: Only if your costs are flat. If you wrap GPT-4 and charge $20/month, you will be destroyed by arbitrage bots. You must have a fair use policy or caps.

Conclusion

The "Seat" is dead because AI Agents don't sit in chairs. They live in servers. They scale infinitely.

If you are building AI software in 2026 with a 2015 pricing model, you will either go bankrupt (from un-capped API costs) or fail to capture the value you create. Stop selling software. Start selling work. The winner of the next decade is the company that best aligns Price with Value.

Appendix C: Expert Interview (Jason Lemkin, SaaStr)

Q: Is the per-seat model dead?

A: It's dying. If you sell a CRM, seats are fine. If you sell an AI agent, seats are stupid. You don't charge for electricity by the "socket," you charge by the kilowatt. AI is electricity.

Q: How do you transition without angering customers?

A: Grandfathering. Keep existing customers on the old plan. Launch the new plan for new logos only. Eventually, the old customers will ask to switch because the new plan has features they want.

Q: What about hybrid pricing?

A: That's the winner. $29/mo platform fee + Usage. It gives you recurring revenue stability (ARR) plus potential upside (NRR).