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.

Purple Main takeaway slide contrasting discovery and exploration with credentials, payments, and checkout.Open full source frame
Discovery benefits from non-determinism; credentials, payments, and checkout require determinism.

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.

0:170:28
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:17 · section reference included

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.

FailureConcrete example
Wrong placeAn Amazon lookalike on a different domain
Wrong thingAn orange T-shirt instead of a purple one—or a much more expensive item
Wrong amountAn extracted price misses currency differences, taxes, or price changes
Wrong credentialA 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.

Purple slide titled The ideal approach listing binding to a merchant, spend policy, API-driven interactions, and verifiable identities.Open full source frame
The ideal approach: merchant binding, spend policy, APIs, and verifiable identities.
2:412:49
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:41 · section reference included

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.

Seller payment request — unchanged
$50 charged using the granted shared payment token

Operation: Stripe checks the requested amount against the token’s $25 mandate.

Seller request

Before: Request awaiting enforcement
$50 — awaiting enforcement
After: Request rejected · Changed
$50 — rejected for exceeding the mandate

Token amount limit

Before: Request awaiting enforcement
$25
After: Request rejected · Unchanged
$25

Authorized seller

Before: Request awaiting enforcement
The internal test seller
After: Request rejected · Unchanged
The internal test seller

Token validity

Before: Request awaiting enforcement
Thirty days from creation
After: Request rejected · Unchanged
Thirty days from creation
Receiving a credential does not give the seller authority to exceed its mandate.

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?

4:505:01
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:50 · section reference included

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.

Sequence diagram with Agent, Seller, and Stripe columns, showing checkout creation and updates, responses, SharedPaymentToken creation, and payment processing.Open full source frame
Checkout and payment exchanges between Agent, Seller, and Stripe.
11:1511:28
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:15 · section reference included

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.

12:5213:04
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:52 · section reference included

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.

14:2814:41
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:28 · section reference included

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.

16:0716:21
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:07 · section reference included

Resources

From the talk

Transcript download
Full transcript

Loading transcript…