Definition
A payment mandate is a delegated, bounded authorization that lets one party, such as an AI agent, make payments on a principal's behalf within defined rules: which payments are allowed, up to what amount, for how long. In agentic commerce it is how a human grants an agent permission to pay while staying in control, and a server-side spend limit is one concrete form of it.
Put plainly, a mandate is permission to pay, with guardrails. The principal does not approve each payment; instead they define the bounds once, and the authorized party transacts within them. That combination, delegation plus constraint, is what makes a mandate useful for autonomous agents: it lets an agent pay on its own without the principal losing control, because the mandate both grants the authority and limits it.
Where the term comes from
The term predates AI agents. In traditional finance, a mandate is a standing authorization to move money on someone's behalf within agreed terms, the way a direct-debit mandate lets a biller collect from an account under rules the account holder agreed to. The common thread is delegated authority that is bounded and revocable: the principal grants permission, defines the limits, and can withdraw it.
Agentic commerce borrows this idea directly. As AI agents began needing to pay on a human's behalf, the natural model was a mandate: the human delegates payment authority to the agent within constraints, just as they would to any other party acting for them. So a payment mandate for an agent is the familiar concept of bounded delegated authority, applied to a new kind of delegate, autonomous software, which is why the term carries over cleanly from finance into the agent world.
What a mandate specifies
A payment mandate specifies the shape of the authority being granted. Typically that includes what payments are allowed, the kinds of transactions or counterparties in scope; how much, a cap per transaction and often a total over a period; and how long, the window during which the mandate is valid. Some mandates add more conditions, but these, what, how much, and how long, are the core.
Together these turn open-ended permission into bounded permission. Without limits, delegating payment authority would mean handing over unlimited spending, which no principal wants. The mandate's specifications are exactly what make delegation safe: the agent can pay, but only the allowed kinds, only up to the cap, only within the window. A well-defined mandate is therefore not just a grant of authority but a description of its boundaries, and the boundaries are what let the principal delegate with confidence rather than trust.
Mandates in agentic commerce
In agentic commerce, mandates are central to how agents pay on a human's behalf, especially in card-network approaches. When an agent buys from a merchant on a person's funded credential, a mandate is what authorizes that: the human grants the agent permission to spend on their card within limits, and the agent transacts under it. Industry efforts around agentic payments, including protocol work on how agents present delegated authority, formalize this mandate model so a merchant can trust that an agent's payment is properly authorized.
The mandate model fits the agent-to-merchant shape of agentic commerce well, because there is a clear principal, the human, delegating to a clear agent. It is the mechanism that lets a person say to an agent, you may shop for me within these bounds, and have that authority be checkable by the parties involved. So when you read about agents buying on a human's behalf, a payment mandate is usually the authorization underneath, which is why the concept is foundational to that part of agentic commerce.
How it relates to a spend limit
A spend limit is one concrete form of payment mandate. The general idea of a mandate, bounded, delegated authority to pay, is implemented for an agent's wallet as a spend limit: a per-transaction cap and a period allowance, enforced server-side where the agent cannot override them. When a human sets that limit, they are defining a mandate the agent must operate within, even if the word mandate is not used.
The difference is mostly framing and context. Mandate is the broader term, common in card-network and traditional-finance settings, for delegated payment authority. A spend limit is the specific, enforced control on an autonomous agent's wallet that expresses such authority for per-call payments. Both answer the same need: let the agent pay autonomously while the principal stays in control via bounds. So if you have set up an agent's spend limit, you have created a payment mandate in practice, and the mechanics of doing so are covered in how-to-set-up-agent-spending-limits.
Why it matters
A payment mandate matters because it is what makes delegating payment to an agent safe and scalable. Without a mandate, you face a bad choice: either approve every agent payment, which does not scale to agent speed and frequency, or grant unlimited authority, which is reckless. The mandate resolves this by letting the principal set bounds once and the agent transact freely within them, preserving both autonomy and control.
It also matters for trust between parties. When an agent pays a merchant, the mandate is what assures the merchant the payment is authorized, not the agent acting beyond its remit. So the mandate serves two roles at once: it bounds the agent for the principal's safety, and it signals legitimate authority to counterparties. As agentic commerce grows, the mandate, in whatever concrete form, is the construct that keeps delegated agent payments both safe and trusted, which is why it is worth understanding as its own concept.
Changing and revoking a mandate
A defining feature of a mandate is that the principal can change or revoke it, and this is worth understanding because it is what keeps delegation reversible. A mandate is not a one-time handover of authority; it is standing permission the principal continues to control. If circumstances change, the principal can tighten the limits, narrow what is allowed, or revoke the authority entirely, and the agent's permission changes accordingly.
For an autonomous agent, this maps onto adjusting or removing its spend limit, and onto being able to cut off an agent that misbehaves. Setting a mandate looser for a trusted agent and tighter for a new or risky one, and revoking it outright in an emergency, are all expressions of the principal's continuing control. So a mandate is best thought of as a living authorization rather than a permanent grant: it is defined once, but it can be revisited whenever the principal needs to, which is part of why mandates are a safe way to delegate payment authority rather than a risky one.
Related terms
A payment mandate connects to several concepts. A spend policy or spend limit is its concrete form for an autonomous agent's wallet. Agentic commerce is the broader setting where mandates authorize agent payments. Agent payment identity is the related trust layer, who the agent is, while the mandate is what it is authorized to do. And delegated authority is the general principle a mandate expresses.
Understanding payment mandates is what lets you reason about how an agent is allowed to spend, distinct from how it pays or who it is. To implement the concrete spend-limit form, see how-to-set-up-agent-spending-limits; for the broader setting, see what-is-agentic-commerce. Pricing is on the pricing page.