Answers · agent payments
How do I revoke an AI agent's spend authority mid-task and freeze payments that are already pending?
Last updated
TL;DR: When an agent is already mid-task and money may be in flight, you need a kill switch for spend — not just a general access revoke and not a spend cap that still allows until the limit is hit. Revoke the agent's Rightshold credential (or freeze the account) so every new authorize_spend, credential verify and gate check refuses it immediately; treat any signed allow receipt that has not yet been accepted by a merchant as frozen by refusing it after revoke and honouring its short valid_until window; freeze or cancel the payment rails the agent holds (Issuing card inactive, wallet pause, provider key revoke); notify owners and counterparties; and write an append-only trail the agent cannot edit. That is distinct from how to build a kill switch for an autonomous AI agent (stop tools and access in general) and from spend-cap pages (limits that still allow until hit). revoke_agent is the permanent credential cut; check_revocation and authorize_spend confirm deny-after-revoke; ledger_verify and record_ai_run keep the trail checkable.
What should I check, step by step?
1. Decide what "mid-task" means for you: a running tool loop, an open checkout, an Issuing authorization still pending capture, or an x402 payment that may still settle. Write the stop path for each rail before you need it.
- Revoke the agent's Rightshold credential with revoke_agent (owner account key) and a clear reason (rogue_behavior, compromised_key, policy_violation). Revocation is irreversible; resuming means a new credential with a new key.
- Confirm deny-after-revoke: check_revocation returns the entry; the next authorize_spend for that credential must return a signed deny; credential verify and gate checks must refuse it.
- Freeze money already authorized but not settled: merchants must accept Rightshold allow receipts only before valid_until (15 minutes); after revoke, treat any unused allow as void and tell merchants/owners not to capture. On card rails, set the Issuing card to inactive (reversible) or canceled; on wallets, pause or revoke the key the agent holds.
- If the blast radius is the whole account, not one agent, use account_controls freeze so spending, listings and new work stop while you rotate keys.
- Notify owners and any counterparty that may still be holding a pending authorization: who revoked, which credential, which open amounts, and what to do with unsettled receipts.
- Write the revoke, every subsequent deny, and any card/wallet freeze to an append-only ledger outside the agent's credentials. Denials and abandoned pending payments matter as much as successful spends.
- Drill it: start a task that calls authorize_spend, revoke mid-run, confirm the next authorize is denied, confirm an expired or post-revoke allow is refused by your merchant check, then confirm a new credential is required to resume.
How do I revoke an AI agent's spend authority while a task is still running?
A spend cap still allows purchases until the total hits the ceiling. A general kill switch stops tools, but money can keep moving on a card or wallet the agent already holds if you only pause the process. Mid-task spend revoke means the credential that authorizes purchases is burned while the run is still going.
- Rightshold's kill-switch registry records the revocation on the ledger and makes every Rightshold check refuse that subject from that moment: credential verify, spending authorization and gate checks. NIST SP 800-53 Rev. 5 AC-3 (access enforcement) and AC-12 (session termination) are the control language for cutting approved access when conditions change; treat a mid-task revoke the same way for agent spend.
- How to revoke an AI agent's access immediately and how to build a kill switch for an autonomous AI agent cover the general stop. This page is the money-in-flight cut: refuse new authorizes, hold or cancel unsettled ones, and keep the trail.
How do I freeze or void AI agent payment authorizations that have not settled?
An allow receipt from authorize_spend is a signed decision, not a bank transfer. Merchants should verify it free and accept it only before its valid_until time (15 minutes). After revoke_agent, new authorize_spend calls deny; your merchant adapter must also refuse any allow for a now-revoked credential, even if the clock has not run out.
- Separately freeze the rail that actually moves money: Stripe Issuing cards go inactive (declines every authorization, reversible) or canceled (permanent); wallet and API keys the agent holds should be paused or rotated from a trusted machine. Rightshold never holds or settles funds, so card and chain settlement stops only where those systems honour your freeze.
- account_controls freeze is the account-wide emergency stop when you cannot trust a single credential cut alone. Pair it with revoke_agent on the rogue credential so resume cannot quietly reuse the same key.
How do I notify owners and keep a verifiable trail after a mid-task spend revoke?
Tell owners which credential was revoked, which pending amounts were open, and which merchants or counterparties were notified. A silent revoke that leaves a checkout half-done creates disputes you cannot reconstruct later.
- Rightshold writes revocations and spend decisions to a hash-chained, signed ledger. ledger_verify is free and keyless; check_revocation is free; record_ai_run can seal what the model was doing when you cut spend so the revoke and the run stay linked.
- EU AI Act Article 14 (human oversight) and Article 12 (record-keeping) expect deployers of high-risk systems to be able to intervene and to keep logs. A mid-task spend revoke with an append-only trail is that intervention for money movement.
How do I ask Rightshold about this (free, no key)?
Add the MCP server https://www.rightshold.com/mcp to Claude, Cursor, ChatGPT, Grok or VS Code, then ask: “My purchasing agent is mid-task and may have payments pending. Revoke its credential now so every Rightshold spend check refuses it, reason rogue_behavior, and confirm deny-after-revoke.”
{
"tool": "revoke_agent",
"arguments": {
"subject_id": "crd_YOUR_AGENT_CREDENTIAL",
"reason": "rogue_behavior",
"note": "mid-task spend cut — freeze unused allow receipts and Issuing card"
}
}- Needs your owner account key; it's in the trust toolset (connect to /mcp?toolset=trust). Revocation is irreversible: resuming means issuing a new credential with a new key.
- check_revocation is free and confirms the entry; authorize_spend on a revoked credential returns a signed deny — use that as your deny-after-revoke test.
- account_controls with action freeze stops spending, listings and new work on the account while you rotate keys; view shows limits and today's spend.
- ledger_verify is free and keyless; record_ai_run seals what the agent was doing when spend was cut.
Rightshold records revocations and signed spend allow/deny decisions on a hash-chained ledger. It never holds, moves or settles money and cannot freeze your Stripe cards, wallets or provider keys for you. Enforcing merchant refusal of post-revoke allows, card inactive status and settlement holds are controls you run around those records. Not financial or legal advice.
What are the sources?
- NIST SP 800-53 Rev. 5: AC-3 (access enforcement) and AC-12 (session termination)
- RFC 6962: Certificate Transparency (append-only Merkle hash logs)
- EU AI Act, Regulation (EU) 2024/1689: Article 14 (human oversight) and Article 12 (record-keeping)
- Agent kill-switch on Rightshold
- Agent spending policies on Rightshold
- Stripe: Issuing for agents (freeze a card on suspicious spend)
Related
- How to build a kill switch for an autonomous AI agent
- How to revoke an AI agent's access immediately
- How to set a spending cap for an AI agent paying with x402
- How to enforce AI agent payment caps at the execution boundary not in the prompt
Not legal advice. JSON · Markdown · All answers
Get a free API key in one call
No card and no email needed. 100 free credits; the license and policy checks stay free without a key.
curl -s -X POST https://www.rightshold.com/v1/accounts/signup -H "Content-Type: application/json" -d '{"accept_terms":true}'
export RIGHTSHOLD_API_KEY=rs_... # the api_key from the reply (shown once)
curl -s https://www.rightshold.com/v1/licenses/check -H "Authorization: Bearer $RIGHTSHOLD_API_KEY" \
-H "Content-Type: application/json" -d '{"license":"MIT","intended_use":{"commercial_use":true}}'
