Agentic Payments
Agentic payments are payments initiated or carried out by AI agents acting within authority delegated by a person or organization. The agent evaluates conditions and selects an action, while payment controls enforce permitted spending. Institutions use this model for procurement, service purchases and treasury activity.

How Agentic Payments Work
An AI agent interprets a business objective, compares the options in front of it and decides which action to request. When that action moves money, the payment system has to know whose authority the agent is using and what that authority allows.
That authority is the mandate. A person or institution approves it once, and it sets approved counterparties, spending limits, permitted assets and the conditions that send a request to a human. Systems outside the agent's own reasoning check every payment request against it.
A typical flow has five stages:
Define authority. Assign an accountable owner and the conditions under which the agent may spend.
Evaluate the task. The agent uses the information it has to select an eligible action.
Validate the request. Independent controls check amount, destination, permissions and compliance requirements.
Execute the payment. Payment infrastructure signs or submits the transaction on the selected rail.
Record the outcome. The system links the task, the authorization and the payment status for review and reconciliation.
Agentic payments run on cards, bank rails or stablecoins. Stablecoins suit software that needs programmable onchain transfers outside banking hours. Acceptance, cost and control requirements decide the rail.

Agentic, Person-Initiated and Scheduled Payments
Area | Person-Initiated Payment | Scheduled Payment Automation | Agentic Payment |
|---|---|---|---|
Trigger | A person decides to pay | A fixed schedule or predefined event | An evaluated task or changing condition |
Decision | Made by the person at the moment of payment | Fixed in advance by the instruction | Made by the agent among permitted actions |
Authorization | Each transaction, by the person | Once, for a defined instruction | Once, for a mandate, plus payment permissions |
Review evidence | Payer confirmation and execution record | Rule, instruction and execution record | Task, chosen action, mandate and execution record |
The difference is discretion. A recurring payment doesn't become agentic because it runs on its own. An agentic workflow still sends selected actions to a human approver while deciding lower-risk ones itself.
Agentic Payment Protocols
Several open standards cover how agents pay, prove their authority or reach payment tools. Each one works at a different layer of the flow.
Protocol | Backed by | What it does |
|---|---|---|
x402 | Coinbase | Uses the HTTP 402 status code so a machine can pay with stablecoins inside the request itself |
AP2 (Agent Payments Protocol) | Signed intent mandates that prove what a person authorized and travel with the transaction | |
ACP (Agentic Commerce Protocol) | OpenAI with Stripe | Lets shopping agents discover merchant catalogs, place orders and check out |
MCP (Model Context Protocol) | Anthropic | Connects AI models to external tools, including payment tools; not a payment rail |
Business Use Cases
A procurement agent compares approved suppliers and buys a service within budget.
A software agent pays per request for data, APIs or compute when a task needs them, without a person entering payment details each time.
An accounts payable agent matches invoices against delivery data and routes vendor payouts. Finance keeps approval authority, exercised over the mandate and the exception queue instead of over each invoice.
A treasury agent proposes liquidity movements from balances and forecasts, and executes them only between approved wallets and counterparties, inside set risk limits.
A typical mandate allows small purchases from a defined supplier list and sends larger commitments to a finance approver. For use cases and build guidance for fintechs and PSPs, read our guide to agentic payments for fintechs and PSPs.
Risks and Required Controls
Agents read untrusted inputs. A prompt injection tries to change a destination or convince the agent that a fraudulent payment is necessary. Payment controls must inspect the resulting transaction on its own terms and ignore the explanation the model gives for it.
Keep credentials away from the runtime. An agent that requests a transaction should never hold signing authority, and it should never be able to change its own spending rules. Read how MPC keeps signing keys away from AI agents.
Limit totals, not only individual amounts. An agent that stays under a per-transaction limit can still repeat that payment many times, so set aggregate budgets, rate limits and duplicate checks as well.
Plan for revocation. If an agent is compromised, the attacker inherits a working mandate, and containment depends on how fast you can withdraw it at the signing layer, across every chain and rail the agent uses.
Keep the evidence. A disputed payment is settled by the mandate, the agent's identity and the authorization record. A model-generated rationale proves nothing. These controls are also the questions to put to a vendor, covered in our guide to choosing an agentic payments infrastructure provider.
How Utila Can Help
Utila provides the wallet and transaction layer of agentic payments infrastructure. Your application defines the agent, its task logic and the mandate. Utila enforces the mandate at signing.
Each agent gets its own MPC wallet, isolated from your other users and wallets, with its own identity, permissions and spend limits.
Keys are held as MPC shares split between Utila and your organization, so the agent never holds a private key.
The policy engine sets spend limits, destination allowlists and approved contracts before the agent signs, and you decide which actions clear automatically and which go to a human.
AML and KYT screening and a full audit trail apply to every agent-initiated transaction.
Agents pay in stablecoins without holding native gas tokens, and they connect through Utila's MCP servers and CLI.
See how these controls fit together in our wallet infrastructure.

