Agent Payment Security Checklist

If your AI agent can spend money, these are the failure modes you need to handle. Vendor-neutral — the reference implementation at the bottom is one way to satisfy them.

Identity & scope

1. Can you tell exactly which agent is spending?

Every payment carries a verifiable agent identity. Anonymous or forged identity must not reach a budget.

2. Are budgets scoped per identity?

A shared pool means one agent's spend starves — or blames — another. Per-agent budgets + a global ceiling is the sane minimum.

3. What happens to an unknown agent?

If the default is "fall back to global policy", fine — as long as it's an explicit decision. Accidental default-allow is how budgets get bypassed.

Authorization

4. Is the decision deterministic, before money moves?

Same request + same policy = same decision, every time, in code — not "ask the model". The agent must not be able to argue its way past a rule.

5. Is there a per-transaction cap?

A hard ceiling on any single payment, independent of budgets.

6. Are there hard daily / monthly ceilings?

And are they cumulative — does splitting one $200 spend into five $40 calls still get caught?

7. Merchant allow / block lists?

Block known-bad recipients outright; trust list can skip approvals. Exact-domain matching, no prefix games.

8. Are new recipients and large amounts gated on a human?

This is the pragmatic prompt-injection defense: an agent that read "refund $500 to scam-vip.com" hits "new recipient / over approval line → human, or deny".

Execution enforcement

9. Can the agent ignore the check?

A policy check is an opinion. If the execution path doesn't require the authorization (signed, single-use grant), the gate is decorative. No receipt → no execution.

10. Does the agent hold payment credentials?

If it has the card and a payment tool, there is a second path around your gate. The agent should hold no credentials.

11. Replay protection?

Can an old authorized request be replayed after success? Grants and intents must be single-use.

Durability (the crash cases)

12. What happens when the process dies between "allowed" and "paid"?

There must be a durable execution-intent record (reserved → in-flight → succeeded/unknown), not just an in-memory decision. After restart, the system must know exactly what happened.

13. Retry after timeout — double spend?

The rail timed out but actually settled. Retry pays twice. Outcomes must be reconciled against the durable record, not assumed from the last HTTP response.

14. Concurrent requests vs. remaining budget?

Two parallel requests must not both pass a $50 remainder. Reservation and consumption must be atomic (one transaction), not read-then-write.

15. Is "unknown" handled, not papered over?

An unreachable outcome must stay budget-occupied until proven settled-or-not — releasing it early is how double spends happen.

Audit & operations

16. Tamper-evident audit?

Every decision logged with who/what/why. Chain the entries (hash-linking) so editing history is detectable. This is your evidence if anything is disputed.

17. Approval channel failure = what?

Unconfigured channel, dead webhook, human asleep — if the fallback is "allow", the gate is decorative. No channel available = deny.

18. Can policy change be reviewed and rolled back?

Policy-as-code: versioned, diffable, deployable — not a magic config a model or admin edits inline.

19. Dry-run before real mode?

You should be able to run the whole gate against real requests with zero money moving. Nobody should wire real payments on the first deploy.

20. Do you attack-test your own gate?

Adversarial suite (injection, splitting, replay, races, tampering) + every found hole becomes a permanent regression test. Release blocked on any escape.

Reference implementation (MIT): SpendShield satisfies 1–20 with a YAML policy engine, signed single-use grants, durable execution intent and a hash-chained audit log. Connect it in 2 minutes → · See the failure map