AI Governance · Field notes

AI Agents Can Spend Money Now. Who Inside Your Company Authorizes It?

By Infonaligy · Updated November 6, 2026 · 9 min read

signed mandate / bounded spend authority

The cryptography arrived before the governance did. Over the past twelve months the payments industry built a credible technical answer to a hard question: how do you prove that an autonomous software agent was genuinely authorized by a specific human to spend a specific amount at a specific merchant? That problem is largely solved, signed, and heading toward standardization. The question nobody answered is the one that lands on your desk. Inside your company, who is allowed to grant an agent spend authority, against which budget, up to what limit, and how would your controller reconstruct the decision six months later during an audit? Most enterprises cannot answer that today, and their agents are already spending money.

What actually changed in agent payments between 2025 and 2026

In September 2025, Google published the Agent Payments Protocol (AP2), an open, vendor-neutral, payment-method-agnostic specification backed by more than 60 partners including Mastercard, PayPal, Coinbase, American Express, and Salesforce. AP2 was designed to be rail-agnostic from the start. Cards, bank transfers, and stablecoins are all treated as first-class settlement options rather than bolt-ons.

The important milestone came on April 28, 2026, when the FIDO Alliance announced that AP2, along with Mastercard's Verifiable Intent (co-developed with Google), had been contributed to it. That contribution is what moves this from a single vendor's initiative toward something that behaves like an industry standard, with the governance and conformance machinery that implies.

Then the card networks moved. On June 10, 2026, at its Payments Forum, Visa announced a partnership with OpenAI to support Visa payments inside agentic commerce experiences, and the same day Mastercard launched Agent Pay for Machines, aimed at software-to-software payments with no human in the loop at transaction time. Visa also operates the Trusted Agent Protocol and Mastercard operates Agent Pay. Both are network-specific programs on card rails, and the two networks chair the FIDO working group developing AP2, which points toward layering rather than competition.

Outside the card rails, in August 2026 OSL Group launched AgentPay, a stablecoin payment system that lets AI agents pay on behalf of developers, with the API handling routing, transaction signing, and settlement. Its design target is intent-based, high-frequency, small-dollar payments, which is exactly the shape of machine-to-machine spend that card interchange handles poorly. A week earlier, on July 30, 2026, Google gave its Gemini Spark agent the ability to operate desktop Chrome in the US using the user's logged-in accounts and saved passwords, handing control back to the user at the payment step.

Read that last item carefully, because it is the one that should worry a CISO. An agent driving a real browser session with saved passwords is not using a mandate at all. It is using your employee's credential delegation by default, with no cryptographic record of what was authorized.

What AP2 mandates actually prove

AP2's core construct is the signed Mandate. The current v0.2 specification defines two types, the Checkout Mandate and the Payment Mandate, secured as SD-JWT verifiable digital credentials. When an agent acts with no human present, each comes in two stages: an open Mandate the user signs in advance, and a closed Mandate for the specific transaction. The original 2025 release used the names Intent, Cart, and Payment Mandate, and many vendor explainers still do. They are worth understanding plainly, because the distinctions map directly onto controls you already run.

  • The open Mandate (originally the Intent Mandate) captures what the user authorized in advance, in the abstract: buy this category of thing, under these constraints, up to this amount, within this window. It is the delegation itself, signed before anyone knows the exact item or price. This is the one that matters most for enterprise governance, because it is where limits live.
  • The closed Checkout Mandate (originally the Cart Mandate) captures the concrete transaction the agent assembled: these specific items, this merchant, this total, at this moment. It is the bridge between an abstract grant of authority and a real purchase, and it is what proves the agent stayed inside the intent.
  • The closed Payment Mandate is what travels to the credential provider and, where applicable, the payment network, signaling that this transaction was agent-initiated and carrying evidence of the authorization chain, so those parties can make a risk decision knowing a human was not clicking the button.

The genuinely new thing here is not the payment. Cards and tokenization have existed for decades. The new thing is a signed, non-repudiable record of authorization that travels with the transaction. Historically, "who approved this purchase" lived in a workflow tool, a purchase order, or somebody's inbox, disconnected from the payment rail. AP2 makes the authorization itself a first-class, verifiable artifact, which means for the first time a controller can, in principle, cryptographically tie a charge back to the specific grant of authority that permitted it. That is a large improvement over the status quo, and it is precisely why the internal governance gap is now the binding constraint rather than the technology.

The payments industry solved agent authorization cryptographically before enterprises solved it organizationally

AP2's signed Mandates (Checkout and Payment, secured as verifiable digital credentials) let a merchant, payment network, and auditor verify that a specific agent was authorized by a specific principal for a specific transaction. What no standard supplies is the internal answer: which role inside your company may grant an agent spend authority, at what single-transaction and cumulative limit, against which GL account, over which approved vendors, and with what expiry. Enterprises that adopt agentic payment rails without first defining that authorization model will inherit auditable evidence of spending they never governed. The correct sequencing is to build the internal spend authority model first, then attach it to the rail, because the rail will faithfully sign whatever authority you were careless enough to grant.

Where AI agents are already spending your money

The consumer framing of agentic commerce, an assistant booking a flight or buying groceries, is a distraction. It hides the fact that in most mid-market and enterprise environments, agents and agent-adjacent automations are already committing funds, usually without a single line item in policy that says so. Gartner has predicted that 40% of enterprise applications will feature task-specific AI agents by the end of 2026, up from less than 5% in 2025. A meaningful slice of those applications sit adjacent to a budget.

Before your company formally approves anything called "agent payments," look here:

  • Cloud spend. Autoscaling and optimization tooling that provisions capacity, buys reserved instances, or resizes fleets is committing dollars on a rule set nobody in finance reviewed.
  • Advertising. Automated bidding and budget-pacing systems have been spending real money with minimal human touch for years. They are the oldest agentic spenders in the building.
  • SaaS and small-dollar subscriptions. Seat-based auto-expansion, usage overages, and API metering charge cards without an approval event. Add an agent that signs up for a tool to complete a task and you have unmonitored vendor creation.
  • Procurement and vendor renewals. Tooling that drafts, compares, and increasingly executes renewals. This is the fastest-moving area, and it is where AI procurement and spend agents are being piloted with the least scrutiny.
  • Freight, expedite, and logistics fees. Systems that select carriers and accept expedite surcharges under a service-level rule are making purchasing decisions in real time.
  • Developer and platform spend. API credits, model inference, data feeds, and per-call services billed to a card on file, often at a volume where no single charge trips a threshold.

None of that arrived through a governance decision. It accumulated. The agentic payment standards simply make the pattern explicit and give it a name.

A practical authorization model for agent spend

Treat an agent as a spending entity with a named human owner, not as a feature of an application. The model below is deliberately boring, because it maps onto controls your finance and audit teams already understand.

Who grants authority

Spend authority for an agent should be granted by the budget owner for the GL account being charged, not by IT, not by the team that built the agent, and not by whoever holds the API key. Every agent needs a named accountable human, a documented business purpose, and a sponsor who would be asked about the spend in a budget review. Build this on top of proper agent identity and access, meaning each agent has its own distinct identity and credential rather than borrowing a service account or a person's session.

Limits that actually bind

  • Single-transaction cap and a separate cumulative cap per period. These are different controls and both are required. An agent limited to $500 per transaction with no cumulative cap can spend $50,000 in an afternoon.
  • Velocity limits. Transactions per hour and per day. Agents fail fast and loop, and a runaway retry loop is the most likely first incident you will have.
  • Merchant and vendor scope. An allowlist of approved vendors or merchant category codes. An agent that can pay anyone is a fraud channel waiting for a prompt injection.
  • Budget and GL mapping. Every agent's authority is bound to a specific cost center and GL account before the first transaction, not reconciled afterward.
  • Human approval thresholds. A dollar amount above which the agent must stop and escalate to a person, with the escalation path designed deliberately. Thoughtful human escalation design is what keeps approvers from rubber-stamping, which happens quickly when the queue is noisy.
  • Expiry and renewal. Authority should be time-bound (90 days is a reasonable default) and expire by default rather than persist until revoked. Renewal should require the budget owner to reaffirm.
  • Dual control on limit changes. Changing a limit must require two people. Otherwise the limit is advisory.
  • A kill switch. One documented action that revokes an agent's payment capability immediately, tested on a schedule, with a known time-to-effect. If your only revocation path is calling the card issuer, you do not have a kill switch.

The control failures to look for right now

Most of the exposure today is not exotic. It is ordinary control weakness, applied to a non-human actor that operates faster than the controls assume.

  • Shared corporate cards. An agent using the same card as a team means the statement cannot attribute a charge to the agent, and revoking the agent means reissuing the card for everyone.
  • Standing credentials. Long-lived API keys and saved browser passwords give an agent unbounded, unexpiring authority. Google's Gemini Spark operating Chrome with saved passwords is the mainstream version of this pattern.
  • No per-agent attribution. If the statement line is indistinguishable from a human purchase, you have no detection capability at all.
  • No reconciliation path. There is no link from the agent's action and reasoning to the resulting GL entry, so the controller sees an amount with no provenance.
  • No fast revocation. Revocation that takes a support ticket and a business day is not a control against something transacting at machine speed.
  • Procurement policy that assumes a human buyer. Most policies specify approval by title and signature. They contain no concept of a non-human requester, so agents fall outside the policy rather than violating it.
  • Segregation of duties collapse. This is the serious one. If the same agent selects the vendor, negotiates or accepts the price, and executes the payment, you have combined three roles that every controls framework insists on separating. Enforcing segregation of duties for agents means splitting selection, approval, and payment across different agents or different identities with different authority, and never letting a single agent close the loop unsupervised above a trivial threshold.

What your controller needs to reconcile an agent transaction

Auditability is where the mandate model pays for itself, but only if you capture the evidence at the time of the transaction. At minimum, retain and link:

  • The agent identity and version, plus the named human owner and sponsoring cost center at the time of the spend.
  • The open Mandate that granted authority: its scope, limits, effective dates, who signed it, and the approval record behind it.
  • The closed Checkout Mandate for the specific purchase, so the line items and total are provably what the agent assembled.
  • The closed Payment Mandate and the resulting authorization and settlement identifiers from the processor, so the ledger entry joins to the rail.
  • The triggering business event: the request, workflow, or condition that caused the agent to act, with the prompt or input that initiated it.
  • Any human approval captured at an escalation threshold, including who approved and what they saw.
  • The GL account and cost center assigned before the transaction, not derived afterward.

Store this as immutable, timestamped records with a retention period matching your financial records policy. This is a specific application of general audit evidence and logging discipline, and it is far easier to build now, while agent volume is low, than to retrofit after a year of untracked spend.

What to do in the next 90 days

  • Days 1-15: inventory. Find every existing automation and agent that can commit funds, including the six categories above. Ask finance for card-on-file vendors and match them against systems no human logs into. Expect surprises.
  • Days 16-30: assign owners. Every discovered spender gets a named human owner and a cost center. Anything without an owner gets shut off or explicitly sponsored.
  • Days 31-45: separate the credentials. Move agents off shared cards and shared accounts onto per-agent virtual cards or per-agent identities with independent limits. Virtual card numbers with merchant locks and hard limits are widely available today and solve attribution immediately.
  • Days 46-60: write the policy amendment. Add a non-human requester category to procurement policy, define who may grant agent spend authority, and set default caps, velocity limits, expiry, and dual control for limit changes.
  • Days 61-75: build the evidence trail. Ensure agent actions produce logs that join to ledger entries. Test the join with a real transaction and have a controller walk it end to end.
  • Days 76-90: test revocation. Run an actual kill-switch drill on a live agent and measure time to effect. Then run a tabletop on a runaway spend loop and a compromised agent.

Note that none of this requires adopting AP2 or any agentic payment scheme. It is the prerequisite work that makes adopting one safe, and it produces value immediately regardless. Sequencing matters here in the same way it does for workflow automation. The control model comes before the capability, or you spend the following year unwinding it.

What is not ready yet, and where to wait

Being honest about maturity is part of the job. Several things are not ready as of November 2026.

The standards are converging but not converged. AP2 is under FIDO Alliance stewardship, which is the right direction, but conformance programs, certification, and the settled details of dispute handling are still maturing. Visa's Trusted Agent Protocol and Mastercard's Agent Pay are network-specific, and interoperability across schemes in production is early.

Liability and dispute rules are unsettled. If an agent buys the wrong thing inside a validly signed mandate, the chargeback and liability picture is not as clear as it is for card-present or card-not-present human fraud. Until that settles, keep agent-initiated spend in categories where an error is recoverable and the amounts are bounded.

Browser-operating agents are the weak link. An agent driving Chrome with saved passwords produces no mandate, no attribution, and no cryptographic evidence. It is convenient and it is the pattern most likely to appear in your environment without approval. Treat it as shadow IT with a payment method attached, and address it in your AI security and governance program rather than through payments policy alone.

Stablecoin rails deserve caution for now. AP2 treats them as first-class and systems like OSL's AgentPay make high-frequency micropayments practical, but for most enterprises the treasury, tax, and accounting handling is a project of its own. Defer unless you have a specific machine-to-machine use case where card economics genuinely fail.

Where to move now: attribution, per-agent identity, limits, evidence capture, and revocation. Where to wait: high-value autonomous purchasing, novel rails, and anything where a mistake is not reversible.

The practical takeaway

The mandate model is a real advance, and enterprises should welcome it. A signed, verifiable chain from a human's grant of authority to a specific charge is better than every ad hoc approval process it will replace. But the rail only signs what you grant it, and it will produce excellent evidence of a governance failure you did not know you had. The work that determines whether agentic payments become a control improvement or a control incident is entirely internal: naming owners, setting limits that bind, separating selection from payment, and being able to switch an agent off in seconds.

Infonaligy works with companies across Dallas–Fort Worth and remotely nationwide on exactly this kind of work, from custom AI agents that are governed from day one to AI consulting engagements that build the authorization model before the first agent touches a budget. If your agents are already spending and nobody owns the limits, that inventory is the place to start this week.

Infonaligy is an AI-native managed intelligence provider based in Dallas–Fort Worth, working with finance, procurement, and security teams across Texas, Oklahoma, and remotely nationwide.

Agent spend governance

Find out what your AI agents are already authorized to buy.

We inventory every automation and agent that can commit funds, move them off shared cards and standing credentials, set limits that actually bind, and build the evidence trail your controller needs to reconcile an agent transaction.

Agent spend controls · DFW · remote nationwide · governed by default · 800-985-1365