Glossary
AI agent payments explained.
An AI agent payment is any transaction where the buyer is software, the value moved is small, and the cadence is high — thousands of sub-cent settlements per session, not a single monthly invoice. Making that work in production requires choosing the right pricing model, the right payment rail, and the right authorization scope. This page walks through all three.
Pricing models
Three pricing shapes work for agent workloads. Most production deployments combine them — usage-based for the raw consumption, outcome-based for the high-value steps.
- Usage-based. Bill per token, per call, or per cycle as the agent consumes the resource. The cleanest mental model and the easiest to attribute, but it requires sub-cent metering primitives most billing systems don't expose — traditional metered-billing platforms aggregate usage on a billing-period cadence, while agent workloads need real-time per-call attribution.
- Outcome-based. Charge only when the agent delivers a result — a lead booked, a bug fixed, a document generated. Aligns seller incentives with buyer value, and works well for agentic workflows where the cost of input tokens is small relative to the cost of orchestration. Requires cryptographic proof of completion for high-trust environments.
- Credit-based. Pre-purchase a bucket of credits that get burned against metered usage. Caps spend, makes costs predictable, and lets sellers offer volume discounts without dynamic pricing infrastructure. The model behind most metered SaaS that handles AI workloads at scale.
Payment rails
The agent doesn't care which rail moves the money, but the choice has tradeoffs the platform operator has to make explicit.
| Rail | Strength | Tradeoff |
|---|---|---|
| Visa virtual cards | Real card rails; merchants don't need to integrate anything new | Card scheme fees apply per transaction; not viable at sub-cent without aggregation |
| USDC / stablecoin | Programmable, sub-cent settlement, no scheme fees | Buyer needs a wallet; on-ramp friction if user pays in fiat |
| Stripe (metered billing) | Familiar to finance teams; handles invoicing | Aggregates usage per billing period; not designed for real-time per-call metering |
| Off-chain credits | Sub-cent, fast, predictable | Requires a trusted ledger operator; periodic on-chain settlement for audit |
In practice, the right answer is “more than one.” The Nevermined Facilitator abstracts the rail choice — the agent issues an x402 payment header, the facilitator settles via whichever rail makes sense for the size and counterparty of the transaction.
Authorization scope
The riskiest design choice in agent payments isn't the rail — it's how much spending authority the agent gets. Three patterns are emerging:
- Card delegation. The user enrolls a card. The agent gets a scoped virtual card credential — limited to specific merchant categories, daily/weekly caps, and instantly revocable. Power-of-attorney semantics, no card number leaves the user. This is how Nevermined Pay works.
- Mandates. A signed authorization that says “agent X may spend up to $Y on token Z within timeframe T.” The agent presents the mandate at each call; the facilitator checks it's still valid before settling.
- Smart account. The agent operates from its own wallet, funded periodically by the user. Cleanest model for fully autonomous agents, but requires the user to manage a separate balance.
All three coexist; the right pick depends on whether the agent is acting on behalf of a logged-in human (delegation) or as an autonomous service (smart account).
What “agent payments infrastructure” actually has to deliver
Stripping out the marketing language, an agent-payments platform has four moving parts:
- A metering ledger that captures every token, call, or cycle in real time with tamper-proof attribution.
- An authorization layer that issues, scopes, and revokes spend authority for agents.
- A settlement engine that aggregates micro-transactions into rail-appropriate batches and moves the money.
- An observability surface the operator can read in real time — margin per call, cost per agent, revenue per merchant — because financial control lives in the data, not the auth flow.
Nevermined ships all four as one platform. The SDK drops into the request path; the metering, authorization, and settlement happen behind a single API.