Agent payments: safe authorization

ChatGPT Wallet demonstrates a useful architecture for agentic commerce: a person reviews the purchase, authorizes it with biometrics, and checkout receives a substitute credential. This guide translates the announcement into six verifiable contracts for product and payments teams.

Agent paymentsPurchase authorizationAgentic commercePayment security
Wasyra Lab
AI systems and operations architecture
Published
min read
6 min read
Categoría
AI Systems
6contracts before an agent can pay
Conceptual architecture separating the agent and cart, biometric approval, tokenized credential, and merchant confirmation.

Chapter 01

How do you authorize a payment executed by an agent?

Safe authorization requires freezing purchase intent and separating who requests, who approves, which credential is released, and which result the merchant confirms.

An agent can search, compare, and prepare checkout, but it should not turn a vague instruction into a charge. Before payment, the system must freeze an immutable version of the merchant, items, quantities, total, currency, recurring terms, and destination; show it to the right person; collect strong approval bound to that version; issue a substitute payment credential; execute once; and reconcile the result against merchant confirmation. Each stage produces independent evidence. Browser identity proves where a request came from, not that the user accepted the price. Biometrics prove an approval, not that an order was created. A checkout attempt ending in an error also does not prove that no order or hold exists. Safe design treats intent, authorization, payment, and fulfillment as separate contracts and advances only while the preceding contract remains valid.

OpenAI announced ChatGPT Wallet on November 13, 2026, two America/Lima calendar days before this publication. At launch, eligible US users review the merchant, items, total, and card, then approve every purchase with a biometric check. The network then provides a payment token with substitute details rather than exposing the real card to the agent or merchant. Initial availability is limited, and OpenAI frames future delegation through limits and categories as an expectation, not a generally deployed capability today.

Chapter 02

Which six contracts does the payment flow need?

The goal is not to add six screens. It is to make six transitions explicit so each can be tested, audited, and stopped independently.

The first contract authenticates the technical actor: agent, browser, or plugin. The second creates a versioned purchase intent containing a cart hash and every material term. The third binds human approval to that hash, an expiry, and an identity. The fourth releases a least-scope payment credential after approval, never before. The fifth enforces idempotency so retries, reloads, or timeouts do not create two orders. The sixth reconciles authorization, capture, and the merchant order; only merchant evidence permits reporting a completed purchase.

Contract, minimum evidence, and rejection condition
ContractMinimum evidenceReject when
1. ActorAuthenticated origin and valid sessionSignature or session fails verification
2. IntentHash of merchant, cart, total, currency, and termsAny material term changes
3. ApprovalUser, intent, strong method, and expiryIt is reused, expired, or mismatched
4. CredentialSubstitute token issued after approvalIt exceeds merchant, amount, or lifetime
5. ExecutionIdempotency key and durable stateA retry cannot recover state
6. OutcomeReconciled merchant order and payment stateOnly local success exists or outcome is ambiguous
An approval must authorize one exact intent, not an entire conversation or a future cart version.

Chapter 03

Agent identity is not purchase authorization

OpenAI's commerce access guidance uses Web Bot Auth to identify signed requests from its cloud browser. It includes Signature, Signature-Input, and Signature-Agent headers and builds on RFC 9421 HTTP Message Signatures. That lets a CDN or firewall distinguish verifiable traffic from an arbitrary bot. It is a message provenance and integrity property; it does not say that a person approved a purchase, that the amount is correct, or that the agent may act on a particular account.

Keep three decisions separate: admitting traffic at the edge, authenticating the customer within the merchant, and authorizing the purchase intent. A valid signature may allow the request to reach login. Login may bind it to an account. Only a later approval bound to the current intent should release the consequential action. Recording those events with correlatable identifiers makes disputes investigable without storing payment secrets in prompts, agent traces, or general logs.

Chapter 04

Hypothetical example: buying two laptops without duplicate charges

Imagine, hypothetically, that an operations lead asks an agent for two laptops under $3,000 total. The agent finds an offer and prepares the cart. The backend creates intent-417 with SKU, quantity, merchant, shipping, tax, total, currency, and a ten-minute expiry. The interface shows that snapshot; the lead approves intent-417 with biometrics. If the merchant changes tax or substitutes a SKU, the hash no longer matches: the system invalidates approval and asks for another review. It does not reinterpret “under $3,000” as continuing permission.

After approval, the orchestrator obtains the substitute credential and sends create-order with an idempotency key derived from intent-417. The browser times out while the merchant responds. Instead of clicking buy again, the agent queries status with the same key and checks for an existing order or hold. If it finds a bank authorization but no confirmed order, it marks the case ambiguous and escalates; it neither claims success nor retries automatically. Once merchant confirmation arrives, it stores the order ID, captured amount, and receipt, and only then reports that the purchase completed.

Chapter 05

When should you expose structured tools?

The WebMCP draft published on November 13 lets a web application expose JavaScript functions with descriptions and schemas for an agent to invoke. The document is a Community Group Report, not a W3C Standard. Its commerce value is reducing the ambiguity of driving an interface through pixels: a get-cart tool can return normalized terms, and create-order can require a purchaseIntentId. But a well-typed schema does not replace server-side authorization rules.

Treat read tools and consequential tools differently, validate every argument on the backend, and assume page content can be untrusted. An availability tool may run freely. A cart mutation tool needs session limits. An order-creation tool must recheck intent, approval, expiry, idempotency, and merchant policy. The agent proposes the call; the domain decides whether it remains valid.

Chapter 06

How do you evaluate the flow before opening it to users?

Test invariants, not just happy purchases. Change the price after approval and require invalidation. Repeat the same request and require one order. Simulate timeouts after authorization, after capture, and after order creation. Expire approval while the agent waits. Cross sessions and verify that an intent cannot be used with another account. Insert a malicious instruction into the product description and confirm that it cannot alter merchant, quantity, address, or invoked tool.

Measure at least four separate funnels: intent prepared, intent approved, payment authorized, and order confirmed. Do not turn a bank authorization into a sale or a browser error into abandonment. Classify ambiguous outcomes and measure time to reconciliation. Also review false declines from fraud controls: OpenAI's guidance warns that a cloud browser may trigger rules designed to stop bots. Adjusting those rules requires verifiable signals and coordination with the risk provider, not allowing all traffic that claims to be an agent.

  • Zero duplicate orders across retries, timeouts, and redelivery.
  • Zero reused approvals after a material term changes.
  • Every reported success has a confirmed, correlatable order.
  • Every ambiguous case has an owner, timeout, and resolution procedure.

Chapter 07

The decision: delegate preparation before authority

Start by letting the agent discover options, prepare the cart, and explain differences. Keep per-purchase approval until the organization can demonstrate all six contracts under price changes, retries, fraud, cancellations, and disputes. If you later enable preapproval, model it as an explicit policy object: limit, merchant or category, time window, beneficiary, events that require reapproval, and a revocation switch. Do not inherit authority from an open conversation.

ChatGPT Wallet provides an important signal: agent payments can fit existing systems when the person retains explicit review, the real credential stays outside the agent, and the merchant retains the relationship, fulfillment, and support. For a CTO, the opportunity is not removing controls for speed. It is designing controls that make preparation automatic, authority narrow, and execution verifiable. If you need to turn that boundary into an operable architecture, Wasyra's custom service can help design the flow without confusing it with the Agents product.

Written by

Wasyra Lab

AI systems and operations architecture

Wasyra Lab publishes practical frameworks for designing AI agents, automations, and operating flows that survive production.

AI AgentsGuardrailsOperations
More from this author

Series

AI systems that actually reach production

A series on agents, copilots, and guardrails for bringing AI into real work without breaking trust or operations.

Posts in this series

Keep reading

Keep reading