AI Engineer Europe 2026
Building safe Payment Infrastructure for the autonomous economy
Loading slides…
Read the talk
Building safe Payment Infrastructure for the autonomous economy
Safe agent commerce separates recommendations from financial authority: scoped credentials, paid HTTP requests, and structured checkout keep spending under deterministic control.
From a talk by Steve Kaliski
Before you start: Familiarity with HTTP requests, API credentials, and basic online checkout will help you follow the payment flows.
How can robots safely spend money?
How do we let robots spend money—and let businesses safely receive it? Steve Kaliski approaches that question from Stripe’s payment infrastructure: he describes four years leading Issuing, which lets developers create physical and virtual cards, followed by two years exploring agent spending. The buyer increasingly becomes software, but the consequences of a payment remain real.
Discovery benefits from nondeterminism; credentials, payments, and checkout require determinism. A language model can use broad knowledge to recommend code, products, or businesses. That flexibility is useful while deciding what to do. Once the agent starts transacting, the system needs a different boundary: finding something and acquiring authority to pay for it are separate operations.
Agents already spend money. Claude Code and Codex consume services paid for through subscriptions or input and output tokens converted into dollars. The next step is extending that spending beyond the model provider to other businesses, currencies, and payment methods. An agent’s basic loop calls a language model and then calls tools; both sides can incur costs. Search, credential management, and payment tools are therefore part of the spending architecture, not merely conveniences around it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Four ways a browser purchase can go wrong
The baseline approach is to let an agent operate a browser as a human would—the OpenClaw-style interaction Kaliski uses as his example. But navigating a storefront leaves four distinct opportunities for error.
| Failure | Concrete example |
|---|---|
| Wrong place | An Amazon lookalike on a different domain |
| Wrong thing | An orange T-shirt instead of a purple one—or a much more expensive item |
| Wrong amount | An extracted price misses currency differences, taxes, or price changes |
| Wrong credential | A pasted card reaches the wrong destination |
These failures require different protections. Recognizing a familiar-looking page does not establish merchant identity. Finding a product does not establish its final payable amount. And a credit-card number is only one kind of payment credential: other payment methods can be difficult or impossible for an agent to relay through a form.
Browser checkout also makes the process slow and difficult to observe. Navigation is finicky; filling forms and clicking Pay introduce more steps whose outcomes must be inferred. This is the same reason other business applications expose APIs and MCP tools: a human-facing Stripe dashboard and a programmatic integration serve different users. The payment interface should bind to a merchant, enforce spending policies, expose APIs, and provide verifiable identities. Kaliski develops those requirements through three layers: credentials, payment flows, and checkout.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Share a constrained credential, not a card number
Handing someone a raw card number does not attach enforceable limits to its use. You are trusting the recipient to charge the amount you intended. Shared payment tokens move those restrictions into the payment infrastructure. An agent can collect a credential and share a token with the seller instead. Kaliski describes the design as spanning hundreds of payment-method types.
The token carries restrictions analogous to a mandate: which seller may use it, in which currency, for what amount, and over what time period. Stripe enforces those restrictions, and use is auditable. If an agent is deceived by a domain or parses a price incorrectly, the intended seller and amount can still constrain what the credential authorizes. The protection comes from enforcement outside the agent, rather than from asking the model to remember a spending instruction.
The demo starts with an ordinary seller integration: create a PaymentIntent for $50 and use a payment method collected by the seller. Kaliski then introduces a second Stripe account belonging to the agent. In this arrangement, the agent has obtained the payment credential from its human operator or the subscription backing its harness, rather than through the seller’s website.
The demo’s Visa-backed token is limited to $25, expires after thirty days, and is scoped to one internal test seller. The underlying card has a higher credit limit, but that broader authority is not passed through. The agent creates the token, and the seller receives the granted token in place of a payment method it collected itself. The resulting token is shown as active.
Credential isolation does not mean hiding useful information from the merchant. The seller still receives the card brand, last four digits, and credit type. Those signals can feed its existing risk analysis, preserving the information it would normally use to decide whether to accept a payment.
Stripe rejects the seller’s $50 request because it exceeds the token’s $25 mandate. The seller has received a usable credential, but possession does not let it override the constraint. After Kaliski lowers the requested charge, the payment succeeds; he does not state the successful amount. The seller can continue processing payments through its usual workflow while the token narrows the possible financial damage.
The seller’s request cannot override the token limit
Constructed example: Object IDs and the awaiting-enforcement label organize the demonstrated request and result; they are not Stripe API fields.
$50 charged using the granted shared payment token
Operation: Stripe checks the requested amount against the token’s $25 mandate.
Seller request
$50 — awaiting enforcement
$50 — rejected for exceeding the mandate
Token amount limit
$25
$25
Authorized seller
The internal test seller
The internal test seller
Token validity
Thirty days from creation
Thirty days from creation
That resolves credential sharing. Two questions remain: how does a payment correspond to the particular product being requested, and how does the agent complete checkout?
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Attach payment to the requested resource
The Machine Payments Protocol, developed with Tempo, treats a tool call as an HTTP request that may require payment. A prearranged API key can provide access to a service, but an agent’s interaction with a tool may be ephemeral. The server needs a way to state its payment requirements during the request itself.
HTTP 402 Payment Required supplies that boundary. The seller responds with a payment requirement, and the client supplies a credential to obtain the requested good. This connects the payment instructions to the resource being purchased, rather than leaving the agent to infer the relationship from a page.
Kaliski starts a regular web server with payment-protected endpoints, then makes a cURL request as an agent would when invoking a tool. To inspect this first exchange against a configured endpoint, cURL can print both the headers and response body:
bash
curl --include "${PAID_ENDPOINT_URL:?Set PAID_ENDPOINT_URL to the protected endpoint}"
The initial request in the demo fails because payment is required. Its encoded response describes what is being purchased, who receives payment, and the mechanism for paying.
The protocol-aware interaction then proceeds through three visible steps:
- Read the payment request. The demo requests one penny in
pathUSDon the Tempo blockchain, payable to a specified recipient. - Approve the payment. Kaliski explicitly authorizes it.
- Observe the result. The request succeeds, and a transaction is shown on the blockchain.
The seller has supplied its payment instructions in the context of the actual resource request. The client can pay for that interaction without first navigating a separate human checkout.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Negotiate checkout through seller-owned state
Not every purchase is an API call. Physical goods and other commerce flows include taxes, quantity restrictions, and fulfillment choices. Those details must reach both the agent and the human buyer accurately. An agent acting as an intermediary can misrelay them, increasing the risk of disputes and chargebacks even when the payment credential itself is secure.
The Agentic Commerce Protocol, built with OpenAI, supplies standard APIs and objects for expressing checkout. This is the ACP demonstration from the recording; its exact specification version is unspecified, and today’s repository includes later additions, including cart and feed specifications.
The mechanism is a back-and-forth among the agent, seller, and payment service provider. When the agent creates a checkout, updates a quantity, or chooses shipping, the seller responds with the latest checkout state. The agent requests a change; the seller returns the authoritative result. Repeating that exchange keeps the purchase details explicit as checkout progresses toward payment.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From a book recommendation to a paid order
Stripe Press provides the concrete example. Its bookshop has a human-friendly storefront, but the demo also exposes a robot-friendly product catalog in JSON. Images, descriptions, and pricing become structured data the agent can use to select a product and initiate checkout, instead of clicking through pages to reconstruct the catalog.
In a conversational interface, the buyer asks for AI-book recommendations while an adjacent panel displays the agent’s requests. The checkout request includes buyer information, line items, and quantities. The seller returns the cart state, including each item’s base price, applicable tax, and available fulfillment options. The agent can refer directly to those fields rather than extracting them from the rendered storefront.
This is the transition from exploration to a transaction. Discovery may involve web crawling and open-ended recommendations. Once a product is selected, changes to the payment method or shipping choice become programmatic exchanges with the seller. Payment then proceeds using a shared payment token or another mechanism for relaying credentials. The model can still help the buyer choose, but it no longer has to infer the checkout’s financial state from the UI.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Keep the merchant in control
The resulting commerce flow can accommodate cards, crypto, and other payment methods while preserving the seller’s role. The merchant retains its customer relationship and receives the signals and risk data it needs to interact safely with agents. Supporting an automated buyer does not require surrendering the seller’s existing payment and risk decisions.
For a business, exposing only a web UI increases the amount of interpretation an agent must perform. Agent-friendly interfaces make more of the interaction deterministic. For the agent operator, shared payment tokens, wallets, and other credential-management mechanisms constrain accidental spending. Together, these establish a practical boundary: a nondeterministic planner operates within enforced constraints, interacts with verifiable parties, and negotiates through structured state. That is what reduces the radius of financial risk.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Chain storage, recurring budgets, and adoption
The audience first asks where the blockchain portion lives: with Tempo, Stripe, or a separate deployment. Kaliski explains that Stripe supports multiple networks, including Base and Tempo. Transaction data lives on those chains; Stripe replicates a product-facing view of that data in its own system.
A second question makes the budgeting problem concrete: could someone give OpenClaw $25 per week to use with a particular model? Kaliski separates recurring payments from more enduring spending policies:
- Recurring usage: Like a subscription charging the same card periodically, subsequent use can be requested against an ongoing authorization relationship. He compares the idea to OAuth access and refresh flows.
- Broader budgets: He suggests higher limits and creating additional tokens, while retaining the restriction that each token is scoped to an individual seller.
The answer describes repeated authorization and seller-specific limits; it does not specify an automatic weekly budget reset or a shared budget across sellers.
Asked whether Stripe Projects composes these primitives, Kaliski says that it combines shared payment tokens with a way for sellers or SaaS businesses to express their products. Recurring payments supply the monthly billing component.
The final question asks how many agent payments have occurred and how much money has moved. Kaliski says there are no public statistics to share. He describes Stripe as encouraged and interested in supporting more businesses, leaving adoption volume unquantified at the time of the talk.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Entry point for granting and receiving scoped payment credentials, with guides for agents, sellers and Connect platforms.
Official protocol site with entry points for using paid services from agents and adding payments to APIs.
Versioned commerce specifications, OpenAPI definitions, JSON schemas and examples maintained by OpenAI and Stripe.
Further reading
Steve Kaliski and Jeff Weinstein explain the Stripe and Tempo protocol and its integration with Stripe payments.
Stripe’s March 2026 explanation of network agentic tokens and buy now, pay later support through shared payment tokens.
Full transcript
Loading transcript…