← Go back

Guide // MandateGuard

AP2, UCP and x402 vs a spending-policy layer: what is the difference?

By the Ingenious AI team · Published 2026-11-14 · Reviewed 2026-11-14

▸ Run the free live demo See pricing

Free covers 1 agent and 1 policy with the full authorize flow, signed receipts and the approval inbox — no card required to start.

Short answer

Payment protocols (AP2, UCP, x402) and a spending-policy layer answer different questions. Protocols prove a payment was authorised — right agent, valid mandate credential, clean execution. A policy layer decides whether the spend should be authorised at all: this agent, this task, this vendor, this amount, against live caps, allowlists, daily totals and history. MandateGuard is the policy layer: it evaluates every proposed spend before execution and receipts the decision, and its AP2-style intent service gives protocols and counterparties a registered mandate to verify against. Bound the decision first; then let any rail execute it.

What is the difference between a payment protocol and a policy layer?

AP2, UCP and x402 are agent payment protocols: they standardise how an agent's payment is presented, authorised and executed between parties. A policy layer is a decision system that evaluates a proposed spend against a mandate — caps, allowlists, approvals — before authorisation. The two compose in sequence: the policy layer decides whether this spend may happen; the protocol then proves and moves it. MandateGuard is the policy layer; it complements protocols and is not a rail.

Two different questions

Every agent purchase raises two questions that are easy to conflate. Was this payment properly authorised — presented by the right agent, under a valid credential, executed as specified? And should this purchase happen at all — this agent, this task, this vendor, this amount, again? Payment protocols answer the first question brilliantly: they standardise credentials, mandate presentation and authorisation proofs so counterparties can rely on a payment's provenance. They do not answer the second, because the second is not a protocol question — it is a policy question about your budget, your vendors and your appetite, evaluated against live state like today's spend and this vendor's history with you. MandateGuard exists entirely inside the second question.

What the protocols contribute

AP2 (Google's Agent Payments Protocol) centres mandates as verifiable credentials for agent purchases. UCP and x402 address neighbouring parts of agent commerce — capability discovery and payment-required flows for resources. Their shared contribution is interoperability of execution: an agent can pay across merchants and platforms with proofs those parties accept, instead of bespoke integrations per seller. That is real and valuable infrastructure, and it is the layer at which standards bodies like EMVCo work. But notice what none of it decides: whether today's ninth purchase should happen, whether this vendor's third upsell attempt this month is acceptable, whether the amount fits the remaining budget the principal actually set.

What the policy layer contributes

A policy layer contributes judgement with memory. Judgement: each proposed spend is evaluated against caps, allowlist, thresholds and frozen state, returning ALLOW, DENY or REQUIRE_APPROVAL. Memory: every evaluation is receipted into a chain, so today's decision can see yesterday's — the day's total, the vendor's pattern, the duplicate forming. Protocols have credentials; policy has a ledger. The composition is the complete system: policy decides, protocol proves and executes, receipts evidence the decision, protocol artefacts evidence the payment. Remove the policy layer and the system is a flawless execution engine for unexamined decisions; remove the protocol layer and decisions still hold inside your own integrations, which is why policy is the right first investment.

Where MandateGuard's intents meet the protocols

MandateGuard's interoperable intent service is the bridge: an AP2-style registered mandate — principal, agent, merchant scope, budgets, window — that counterparties can reference and verify receipts against, using role-scoped keys. In stack terms, the intent is the mandate object both layers share: the policy layer maintains its budgets and event chain as decisions happen; protocol-facing parties verify against it when executing. That is the practical meaning of alignment in MandateGuard's materials: not a claim to be a rail, but a mandate registry shaped so rails and checkers can build on it. The EMVCo draft framework points the same direction — mandates as first-class, verifiable objects between parties.

Architecture guidance

In your own agent stack, order the layers deliberately. The agent proposes a purchase. The policy check runs first — MandateGuard authorize, or a preview through MCP — and only an ALLOW (or a redeemed approval token) unlocks the payment step, where your protocol or rail of choice executes. Join the artefacts: store the mandate receipt reference with the protocol's payment proof under the same task reference, so an auditor can walk from business purpose to decision to settlement without glue work. And keep the credentials separated: the keys that let an agent ask (agent key, MCP access) must never be the keys that let a human approve, unfreeze or rewrite policy.

The buyer's one-line test

When evaluating any agent-payment offering, ask which question it answers. If the demo shows beautiful authorisation proofs for purchases nobody bounded, you are looking at a protocol demo. If it shows a purchase refused for breaking a cap, a duplicate escalated from history, an approval bound to one execution, and a receipt a third party can verify, you are looking at a policy layer. Most mature deployments will run both kinds of system. The mistake is buying either one believing it is the other — that confusion, more than any single overspend, is what the current wave of agent-commerce tooling is quietly selling.

Five actions to take now

  1. Use payment protocols for what they prove: that a payment was authorised
  2. Use a policy layer for what they cannot decide: whether it should be
  3. Keep mandate checks upstream of protocol execution in your agent's flow
  4. Register intents where counterparties need to verify against the mandate
  5. Refuse architectures where the protocol step is the only control

Worked example: a perfectly authorised mistake

Consider an agent buying a 700-dollar annual platform plan. Through a payment protocol alone, the flow is impeccable: the mandate credential is presented, the authorisation is cryptographically sound, the payment settles. Every proof checks out — for a purchase nobody with budget authority ever agreed to, at ten times the monthly shape of the agent's normal spend, from a vendor the business uses for something else.

With a policy layer upstream, the same purchase meets a per-task cap of 100 dollars and an allowlist before the protocol is ever invoked: DENY, receipted, with the agent re-planning to the 70-dollar monthly tier. The protocol's proofs remain valuable — for the purchases that should happen. The comparison in one line: protocols make agent payments trustworthy as payments; policy makes them trustworthy as decisions.

Frequently asked questions

Is MandateGuard a payment protocol?

No. MandateGuard is the spending-policy layer: it decides and evidences. Protocols and rails execute payments.

Does MandateGuard replace AP2?

It complements it. MandateGuard's intent service is AP2-style for shared mandates, and its policy engine can sit upstream of AP2, UCP or x402 execution.

Can a protocol enforce my budget?

Protocols carry mandate credentials and authorisation proofs; evaluating your caps, allowlists and approval rules against live state is the policy layer's job.

Which do I implement first?

The policy layer, if agents can already pay somehow. Controls precede scale: bound the decisions, then streamline execution.

Where does the receipt fit?

The policy decision produces the mandate receipt; protocol artefacts evidence the payment. Audits increasingly want both, joined by the task or intent reference.

Keep reading

Put the policy in force: spend envelopes · intent registry · approval inbox · how the proof works · all MandateGuard guides