I priced my first AI agent at $200/month. Six weeks later I was staring at an Anthropic invoice that was eating the retainer alive. One heavy user was running 40+ long-context calls a day. Meanwhile the light users churned because $200 felt steep for a tool they opened twice a week.

The problem wasn’t the agent. The problem was that I copied SaaS pricing onto a product that has variable cost of goods sold. SaaS has near-zero marginal cost per seat. An AI agent has real, jagged, per-call cost. Treating them the same is how solo builders quietly go broke.

Here’s the actual pricing model I run now, the math behind it, and the mistakes I’d tell any builder to skip.

Why the three obvious models all fail

Every builder tries one of three defaults. Each one breaks in a specific way.

Per-seat punishes your best customers. The team that adopts hardest and gets the most value is the team burning the most tokens — and you’re charging them the same as the team that logged in once.
Per-action feels like a taxi meter. Users stop using the agent because every click has a visible price tag. Adoption dies, and adoption is what makes the agent sticky.
Outcome-based sounds elegant on a pitch deck. Then you try to prove attribution. Was it your agent that closed the deal, or the SDR? Was it your agent that resolved the ticket, or the macro they already had? You will lose that argument every quarter at renewal.

None of these are wrong in isolation. They’re wrong as the only lever.

The hybrid model: base + credits + cap

The model that actually holds up: a base fee that covers your floor cost and support time, metered credits that scale with heavy usage, and a cap so nobody ever opens an invoice and panics.

Here’s how I structure it:

1. Base fee — covers your floor

The base fee has to cover: your minimum monthly infra (vector DB, hosting, monitoring), a baseline token budget, and the human time you spend on that account (onboarding, check-ins, minor tweaks). For a solo builder shipping a mid-complexity agent, that floor is usually $150–$400/month depending on the vertical.

Rule of thumb: base fee = (fixed infra per account) + (expected support hours × your hourly rate) + (baseline API cost × 1.5 markup).

2. Credits — meter the heavy users

Credits are how you stop subsidizing power users. Every action the agent takes consumes credits based on its real cost. A short classification call is 1 credit. A long RAG query with a 50k-token context window is 40 credits. A full agentic workflow with tool calls is 100+.

Price credits at roughly 2.5–3x your blended API cost. That covers overhead, failed calls, retries, and the fact that model prices shift. Check OpenAI’s pricing page and Anthropic’s pricing page monthly — they move, and your margin moves with them.

3. Cap — kill invoice anxiety

The single biggest objection to usage-based pricing is fear of a runaway bill. Solve it with a hard cap. “Your bill will never exceed $X this month without your written approval.” When usage hits 80% of cap, the agent alerts them and offers to bump the tier or throttle non-critical actions.

The cap is a sales tool as much as a safety mechanism. It’s what lets a nervous buyer sign.

The tier structure I actually use

Three tiers, named by usage profile, not by feature gates:

Starter — $199/mo base, 2,000 credits included, cap at $400. For solo operators or small teams testing the agent.
Operator — $499/mo base, 8,000 credits included, cap at $1,200. The sweet spot for most agencies and small ops teams.
Scale — $1,499/mo base, 30,000 credits, custom cap. For teams running the agent as a core workflow.

Overage credits are sold in packs (e.g., 1,000 credits for $80). Unused credits roll over one month, then expire — this keeps you from carrying an infinite liability on your books.

The mistakes that quietly kill margin

Not logging token usage per customer from day one. If you don’t know which accounts are profitable, you’re flying blind. I use a simple Postgres table that logs every call: customer_id, model, input_tokens, output_tokens, cost, timestamp. That’s it. You can build this in an hour.
Pricing off the sticker rate. Real cost includes retries, failed tool calls, embedding refreshes, and eval runs. Multiply your naive estimate by 1.4x.
Not raising prices when models get more expensive. Anthropic and OpenAI have both raised prices on premium tiers. Your contract needs a clause that lets you pass through model cost changes above a threshold (I use 15%).
Confusing agent pricing with support pricing. If the agent hallucinates and blows up trust, you’re doing free crisis work. I wrote about how that spirals in The Hallucination That Ended the Retainer — bake the trust layer into your base fee, not into free hours.

What to do this week

If you’re already selling an agent flat-rate and suspect you’re upside down, do this in order:

Pull the last 30 days of API costs. Break down by customer.
Find your top 20% of users by cost. Calculate their gross margin. If any are negative, you have your answer.
Draft a hybrid tier sheet using the base + credits + cap structure above.
Grandfather existing customers for 90 days. Move new customers onto the new pricing immediately.
Add usage dashboards inside the product so customers see their own credit burn in real time. Transparency kills billing complaints.

Pricing an AI agent isn’t a marketing problem — it’s a unit economics problem dressed up as one. The builders who survive 2026 are the ones who figured this out before their third overage invoice. And once pricing is solid, the next leak is usually in how the agent is positioned and sold. I’ve been working through that in The Stealth Retainer Cut and the AI slop workflow teardown — worth a read if you’re rebuilding the offer alongside the pricing.

Stop copying SaaS pricing onto agents. They are not the same product.

How to Price an AI Agent Without Bleeding Margin