Designing AI Agents

Billing and Metering Per-User Agents in SaaS Products

Per-user agent billing only works when pricing and infrastructure are designed together.

· 10 min read · Updated
Cover illustration for “Billing and Metering Per-User Agents in SaaS Products”
Per-User Agent Patterns · October 12, 2026 · 10 min read · 2,220 words

You cannot just pick a pricing model off a shelf to solve billing and metering for per-user AI agents. The unit economics only close when you design the billing structure and the underlying agent infrastructure together, because idle agents have to stop costing money if the model is going to survive contact with real users. This piece walks through the billing models that actually hold up, the cost signals you need to track, and how your choice of agent infrastructure decides what kind of billing you can even run.

Why per-seat pricing breaks when agents are the product

A developer ships an "AI included" tier, prices it the way every other feature on the roadmap gets priced, and waits for adoption. An AI agent breaks that assumption at the root: every interaction can trigger LLM inference, tool calls, a multi-step workflow, and real compute cycles, and each of those carries a cost that scales with how hard the user pushes the agent, not with how many seats a company bought.

What cost signals accrue when an agent does work

Before a developer can choose how to charge for an agent, it helps to know what that agent is spending money on, because the billing model can only charge for what the system can actually see and attribute.

Nevermined's billing patterns guide describes this as multi-dimensional value: a single agent session is processing tokens, calling APIs, and producing an outcome all at once, and each of those is a distinct cost signal that needs its own instrumentation. Every call to a model provider returns usage metadata, including input tokens, output tokens, and cache tokens, and that metadata has to be captured where the call happens, not reconstructed afterward from a monthly invoice. It needs to be tagged with customer ID, feature name, and model ID at that moment. An event stream that misses pieces of this data corrupts every pricing decision built on top of it, because there's no way to retroactively recover what wasn't recorded.

The four billing models that work for agent workloads, and the conditions each requires

No single billing model is correct for every agent product. The right choice depends on whether the agent's output can be measured as a discrete outcome, whether usage is predictable enough for customers to plan around, and whether the relationship can tolerate a bill that moves from month to month.

Usage-based or token metering charges for actual consumption, tokens processed, API calls made, compute minutes used, and ties the developer's revenue directly to that cost basis.

Per-task or per-resolution pricing charges for a completed, verifiable outcome, a resolved ticket, a processed document, a booked meeting, for the compute spent getting there. Intercom's Fin AI agent charges $0.99 per resolved conversation, not per conversation started, so if a handoff fails, it never generates a charge. Intercom counts both confirmed resolution, where the customer explicitly acknowledges the answer, and assumed resolution, where the customer simply leaves without asking for more help, and the space between those two definitions is where billing disputes tend to start.

A flat monthly base gives the customer predictability and gives the developer a baseline of recurring revenue, and when you add a usage component on top, it captures value from heavy users and protects margin as the product scales. Whichever model you pick, it determines which cost signals you need to meter, and that choice shapes everything about the pipeline you build on top of it.

Translating raw cost signals into customer-facing billing units

Customers don't want to reason in tokens or compute-minutes, and a billing model that forces them to will create friction even when the total bill is fair.

All of this depends on the infrastructure underneath producing clean, attributable cost data.

Why agent infrastructure architecture determines what billing is possible

The billing model you settle on is not a decision you make in isolation from infrastructure. Outcome-based billing depends on persistent state: an agent that can't carry memory, files, or credentials from one session to the next can't reliably finish multi-step work, and a task that dies partway through still cost compute the developer has no outcome to bill against.

Idle compute costs money on both of these approaches. Serverless approaches push compute cost to the moment of each call but give up state continuity: every invocation starts cold, context has to be rebuilt from external storage, and a multi-step agent workflow ends up needing state management bolted on outside the execution environment.

A persistent agent running in its own isolated virtual machine resolves that tension differently: it can be snapshotted to disk when idle and restored in close to a second when the next request lands, so the agent pays for storage during downtime rather than for held compute, and its memory, disk, and credentials come back exactly as they were. The billing model and the infrastructure it runs on have to agree with each other, or neither works.

Snapshot-restore scheduling and the idle-cost gap for per-user agents

Snapshot-restore is the mechanism that makes per-user agent economics work. When an agent goes quiet between sessions, the microVM's full state, guest memory, virtual device states, CPU registers, gets written to disk as a snapshot, and the compute slot underneath it is released. The next request restores that snapshot through memory-mapped file access, so the agent comes back to exactly where it left off, and it reruns no setup.

The economics follow directly from how agents actually behave: most of them sit idle most of the time, between messages, between sessions, overnight. A further optimization, sometimes called snapshot-once-fork-per-run, builds an agent's environment a single time, snapshots it, and forks a copy-on-write child for each new run, so every run starts from an already-warmed state, packages installed, credentials loaded, browser session live, without repeating any of that setup.

When you choose how to run agents, you are choosing among three operating modes. Scale-to-zero tears the agent down completely between sessions and rebuilds it from nothing on the next request, so it minimizes idle cost, but it throws away state unless you externalize that state somewhere else, and you trade one kind of complexity for another.

The hibernated mode produces the cleanest billing signal of the three: compute gets charged only while the agent is actively running, storage gets charged while it's idle, and that split maps directly onto the usage-based structures described earlier, where the bill reflects what the agent actually did. Maritime's scheduling model is built on exactly this observation: most agents spend most of their time idle, so its snapshot-restore scheduler lets you pay for storage instead of idle compute, and that is what makes running one agent per customer affordable at the scale agentic SaaS products need. That capability is also the precondition for the deployment patterns that follow.

Deploying isolated per-user agents as a fleet: architecture patterns that support per-user billing

The architecture that supports clean per-user billing is one agent per user, each running in its own isolated environment, because the isolation boundary is the only boundary a metering system can trust for cost attribution. Give each user's agent its own VM, its own persistent disk, its own network namespace, and its own credential store, and every cost event, compute time, storage, tool calls, attaches unambiguously to the right account, because nothing shared crosses that line.

Three patterns describe how teams structure this in practice, each with its own billing tradeoff. The bridge pattern splits the difference: shared infrastructure handles the steps that are the same for everyone, authentication, logging, tool invocation, while tenant-specific reasoning runs in its own isolated context, isolating the part of the cost that actually varies while spreading the stable part across all tenants.

Access control at the tool layer matters just as much as compute isolation. If you restrict which tools a given tenant's agent can call, and you log every one of those calls with tenant attribution through a standardized tool-calling protocol, you get both a security boundary and a metering requirement: cross-tenant tool calls can't happen, and every billable call lands on the right account. Once this isolation is in place, the instrumentation work that follows gets considerably more straightforward.

Instrumenting the metering pipeline

If you capture cost events at the moment they happen instead of reconstructing them later from a provider's monthly summary, billing stays accurate, but a pipeline built wrong at this layer corrupts every pricing decision downstream of it. Every LLM call returns usage metadata, input tokens, output tokens, and cache-read and cache-write tokens where the provider supports them, and that metadata has to be logged at the call site with customer ID, agent ID, feature name, model ID, and a timestamp attached, not inferred afterward from an aggregate bill.

A normalization layer sits just above that raw capture. Tool invocations need the same discipline as model calls: every MCP tool call, API request, and external service hit should carry the same customer and agent attribution, because individual tool costs are often small but compound fast across a multi-step workflow. For agents running in persistent VMs, active compute time and idle storage time are two separate signals that map to two separate cost lines, so the metering system has to tell them apart cleanly to produce an accurate bill.

Raw events then have to roll up into per-customer, per-billing-period totals before anything reaches an invoice, and that rollup has to handle timezone boundaries, mid-cycle plan changes, proration, and retries correctly so nothing gets double-counted. Every usage record should also land in an append-only log the instant it's created, which is the foundation of tamper-proof metering and typically a condition of enterprise procurement and compliance review.

If you don't handle three edge cases explicitly, they distort billing more than any others. When batched requests reach a provider as one call, their combined cost still needs to be split correctly across every customer whose request was bundled into that batch.

Billing infrastructure options for developer teams building per-user agent products

Building this well requires two separate pieces of infrastructure, and conflating them is a common mistake: agent compute infrastructure that produces clean per-user cost signals, and a metering and billing platform that can take in high-frequency events and turn them into invoices.

On the compute side, Maritime runs each agent in its own Firecracker micro-VM on bare metal, which gives every user hardware-level isolation and makes the VM boundary itself the cost attribution boundary, so metering doesn't depend on software tagging getting everything right downstream. Flat-rate pricing on Maritime works out to roughly $1 per agent per month, a number that makes running one dedicated agent per customer viable at the scale a real SaaS product needs, and the deployment path goes from code to a live API endpoint in a single push, with the CLI, SDK, and MCP support built into that workflow from the start. This fits teams who build agent-native products that need per-user cost isolation, persistent state, and fast wake times as infrastructure primitives from day one, and who want their billing economics to work before they hit scale, not after.

On the billing and metering side, the options look different because the problem is different. Standard subscription billing tools, including Stripe Billing in its default configuration and most legacy subscription systems, were built for seat-based pricing, so they don't meter high-frequency, sub-cent agent events without a substantial amount of custom engineering. Nevermined itself offers payments infrastructure built for agent workloads specifically: real-time metering, support for usage-based, outcome-based, and value-based pricing, instant settlement, and native handling of agent-to-agent payments through the A2A protocol and MCP, along with cryptographically signed agent identity through DIDs and tamper-proof audit logs, which suits teams that need to meter outcomes as well as raw consumption. Most teams building a real per-user agent product will need one option from each of these two layers, not a single vendor that claims to do both.

Putting it together: a practical billing architecture for a per-user agent SaaS product

A working billing system for per-user agents comes down to five decisions made in sequence, and each one is constrained by the one before it. The billing model has to be chosen first, because it determines everything that follows: outcome-based billing needs measurable task completion and persistent agent state, usage-based billing needs clean per-user cost attribution, and a hybrid model needs both at once, so this choice has to happen before any metering pipeline gets designed. Agent infrastructure comes next, and it has to match whatever isolation the billing model requires: per-user attribution needs per-user execution isolation, and persistent state for outcome-based billing needs a disk that survives idle periods, which the hibernated micro-VM pattern with snapshot-restore provides while keeping idle costs at storage rates. Instrumentation happens at the infrastructure layer itself, capturing LLM call metadata, tool invocations, active compute time, and idle storage time at the point each occurs, attaching customer and agent identifiers to every event, and normalizing costs across models into one common unit. The customer-facing billing unit comes after that: internal signals like tokens, compute-minutes, or completed tasks get translated into something a customer can actually budget against, credits, actions, or resolutions, with tier allowances, overage rates, and spend controls defined before the product launches. Last comes the billing platform itself, chosen for its ability to

More in Per-User Agent Patterns