The checkout problem

Today's AI agents can find the best flight, compare hotel prices, and recommend the perfect gift. But completing the purchase? That still requires a human clicking through checkout flows, entering payment details, and confirming orders.

The gap between "AI found the right thing" and "AI bought the right thing" exists because there's no standard way for agents to interact with merchant checkout systems. Agents either scrape web UIs (fragile, slow, often blocked) or rely on the human to finish the job.

What ACP proposes

Agent Commerce Protocol (ACP) is a proposed standard that defines how AI agents interact with merchant checkout systems programmatically. Instead of navigating a browser, an agent sends a structured purchase request and receives a structured response.

The core idea is simple: merchants expose a machine-readable checkout API, and agents call it with the details of what they want to buy.

A typical ACP flow

  1. Product selection — The agent identifies a product via search, catalog API, or recommendation.
  2. Purchase request — The agent sends a structured request to the merchant's ACP endpoint: item, quantity, shipping details, and a payment credential.
  3. Order confirmation — The merchant validates the request and returns an order confirmation with tracking details.

No browser. No CAPTCHA. No cart abandonment. The entire transaction happens through structured data exchange.

What a request might look like

{
  "action": "purchase",
  "item": {
    "id": "SKU-8827",
    "name": "Ceramic Pour-Over Set",
    "price_cents": 6500
  },
  "shipping": {
    "name": "Jane Doe",
    "address": "123 Main St, Portland, OR 97201"
  },
  "payment_token": "tok_live_abc123..."
}

How ACP relates to MCP

If you're familiar with Model Context Protocol (MCP), ACP is a natural extension. MCP standardizes how AI agents connect to tools. ACP standardizes one specific tool: checkout.

Think of it this way:

An agent using MCP can discover that a merchant supports ACP, then use the ACP protocol to complete a purchase — all without custom integration work for each merchant.

The trust layer: why ACP needs approval controls

A standard checkout API is powerful, but it raises an obvious question: who controls the agent's spending?

ACP defines the mechanical part — how to send a purchase request and receive a confirmation. But it deliberately doesn't handle authorization. That's the job of an approval layer.

Where PettyBot fits in

PettyBot provides the approval and spend-control layer between your AI agent and ACP-compatible merchants. When your agent wants to buy something, PettyBot sends you a push notification. You approve with FaceID, and PettyBot issues a scoped payment token the agent uses to complete checkout via ACP.

This separation of concerns is important. The checkout protocol handles the transaction mechanics. The approval layer handles the trust mechanics. Neither needs to know much about the other.

What needs to happen for ACP to work

ACP is still a proposal, not a deployed standard. For it to succeed, several things need to come together:

The bigger picture

ACP is part of a broader shift toward agentic commerce — a world where AI agents handle the entire purchase lifecycle, from research to checkout, on your behalf.

We're early. Most merchants don't expose structured checkout APIs. Most agents can't complete purchases. But the direction is clear: AI will handle more of the buying process, and we'll need standards like ACP to make that work safely and reliably.

The question isn't whether AI agents will buy things for us. It's whether we'll have the right infrastructure in place when they do.

Further reading