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.
- Published
- min read
- 6 min read
- Categoría
- AI Systems
On this page
7 chapters- 01How do you authorize a payment executed by an agent?
- 02Which six contracts does the payment flow need?
- 03Agent identity is not purchase authorization
- 04Hypothetical example: buying two laptops without duplicate charges
- 05When should you expose structured tools?
- 06How do you evaluate the flow before opening it to users?
- 07The decision: delegate preparation before authority

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 | Reject when |
|---|---|---|
| 1. Actor | Authenticated origin and valid session | Signature or session fails verification |
| 2. Intent | Hash of merchant, cart, total, currency, and terms | Any material term changes |
| 3. Approval | User, intent, strong method, and expiry | It is reused, expired, or mismatched |
| 4. Credential | Substitute token issued after approval | It exceeds merchant, amount, or lifetime |
| 5. Execution | Idempotency key and durable state | A retry cannot recover state |
| 6. Outcome | Reconciled merchant order and payment state | Only local success exists or outcome is ambiguous |
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.
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 seriesMore from this author
More from this author
AI Systems
Agent hooks: 7 tests before tools execute
AgentCore's new lifecycle hooks expose four control boundaries. This guide turns them into seven tests for authorization, failure, and auditability.
ArticleAI Systems
Scientific post-training: 7 evidence gates
Nemotron for Science opens scientific post-training. These seven gates prevent proxy optimization, test leakage, and false improvements.
ArticleKeep reading
Keep reading
AI Systems
Agent hooks: 7 tests before tools execute
AgentCore's new lifecycle hooks expose four control boundaries. This guide turns them into seven tests for authorization, failure, and auditability.
ArticleAI Systems
Scientific post-training: 7 evidence gates
Nemotron for Science opens scientific post-training. These seven gates prevent proxy optimization, test leakage, and false improvements.
ArticleAI Systems
Agentic RL: how to read MLPerf Training 6.1
MLPerf now measures agent post-training. Learn how to read time to quality, workload limits, and useful infrastructure decision signals.
Article