Commerce is moving from web pages to AI workflows. When a buyer asks ChatGPT to upgrade a plan or add seats, something has to translate that intent into a real, authorized transaction against a real billing system. The Agentic Commerce Protocol (ACP) is the emerging open standard for exactly that handoff — and for B2B subscription businesses, it raises a pointed question: is your commerce layer ready to answer an agent?
What is the Agentic Commerce Protocol?
ACP is an open standard, introduced by Stripe and OpenAI (with Meta) and now maintained by OpenAI and Stripe, that defines how AI agents interact with businesses to complete purchases on a buyer's behalf. It's published under the Apache 2.0 license at agenticcommerce.dev, currently in beta, and OpenAI was the first platform to implement it inside ChatGPT. The core idea is deliberately conservative: the merchant stays the merchant of record and the system of record. Orders run on the merchant's existing commerce stack, and payments settle through the merchant's existing payment processor. ACP just standardizes the conversation between the agent and the business.
The building blocks
ACP defines a small set of composable building blocks that any agent and any business can speak:
Agentic checkout — a versioned REST contract for creating, updating, retrieving, completing, and canceling checkout sessions. The merchant returns an authoritative cart state (line items, totals, fulfillment, taxes) on every call, so the agent always renders accurate numbers rather than guessing.
Delegated payment — a secure way to pass a scoped payment token between the buyer, the agent, and the business, so the agent can complete a purchase without ever handling raw card credentials. Stripe's Shared Payment Token was the first compatible implementation.
Delegated authentication, orders, and webhooks — OAuth-based authorization that lets an agent act on a buyer's behalf, plus webhooks that stream order lifecycle events — confirmation, shipping, delivery, refunds — back to the application. ACP works over both traditional REST and MCP.
Why B2B subscriptions are the hard part
The reference flows around ACP are framed in the familiar shape of retail checkout: a cart of items, a shipping address, one payment, one order. B2B subscription commerce doesn't look like that. The transaction an agent needs to execute is usually a mid-cycle upgrade, an add-on, a seat change, a plan switch, or a usage-based commitment — each of which touches proration, entitlements, contract terms, and revenue recognition. And the system of record isn't a single PSP. It's Zuora, Stripe Billing, Maxio, Orb, or Metronome, often with a CRM and an ERP downstream.
That's the gap. An agent can negotiate and assemble a cart, but "complete checkout" against a subscription means correctly applying a billing change to the right account on the right billing platform — atomically, with the right proration, and without double-charging. Exposing an ACP-style surface directly on top of a subscription stack is real engineering, and most teams don't want to hard-wire it to one billing vendor that they may migrate away from later.
Where PeakCommerce fits
PeakCommerce is the API-first, billing-flexible execution layer that sits between protocols like ACP and your billing system. It exposes machine-readable commerce APIs so an AI agent — or a human — can execute upgrades, add-ons, and billing changes at the exact moment of intent, then commits those changes against whatever billing platform you actually run.
Because PeakCommerce is billing-flexible — with adapters for Zuora, Stripe, Maxio, Orb, and Metronome, plus built-in ordering and direct payment-gateway connections for teams without a billing engine — you can become agent-ready with or without an existing billing stack. The proration logic, entitlement updates, contract handling, and downstream sync to Salesforce and NetSuite live in the commerce layer — not in every agent integration you build. As ACP and other agentic standards mature, your job becomes mapping the protocol to a clean set of commerce primitives rather than rebuilding checkout for each new AI surface.
Getting ready for agentic commerce
The teams that win the agentic transition won't be the ones who pick the "right" protocol — standards like ACP are designed to be interoperable and open. They'll be the ones whose commerce is already exposed as machine-readable APIs, decoupled from any single billing vendor, so a new agent surface is a configuration, not a rebuild. Start by making your upgrade, add-on, and plan-change flows callable through an API, keep them billing-flexible — able to run with or without a billing engine — and let the protocol layer ride on top.
PeakCommerce gives any business that execution layer today — the machine-readable commerce APIs, built-in ordering, and billing adapters that let AI agents act on intent, whichever agentic protocol your buyers show up with.