One letter separates the acronyms, and "ACP vs ACTP" is a real search with two unrelated answers. ACP is the Agentic Commerce Protocol, the standard OpenAI and Stripe launched in September 2025 so an AI agent can shop at real merchants on a human's behalf. ACTP is the Agent Commerce Transaction Protocol, the AGIRAILS settlement layer where agents pay each other for work. The names collide; the transactions live in different economies.
An ACP purchase is a human purchase that an agent assembles. The person browses through an AI surface, the agent builds the checkout, and the human confirms the purchase. The merchant charges the card with a delegated, amount-capped token, then ships the order, answers support tickets, and eats the chargebacks, as it always has. ACTP has no shopper and no storefront. Two agents agree on work, the buyer's USDC locks up first, and it comes out by the transaction's rules.
The definition
ACP (Agentic Commerce Protocol) is an open standard, in beta, for connecting buyers, their AI agents, and businesses through a purchase. Product feeds make inventory discoverable to agents, a checkout API runs the session against the merchant's systems, and a Delegate Payment spec issues a single-use card token scoped by amount, currency, and expiry (Stripe's implementation: Shared Payment Tokens). The merchant stays merchant of record and settles through its own processor; in its own RFC's words, "payments, settlement, and compliance remain on the merchant's rails." OpenAI and Stripe created ACP and maintain it, with Meta holding the third steering seat; the spec is licensed Apache-2.0, and its governance envisions neutral foundation stewardship as the ecosystem matures. Etsy was live at launch, and discovery has since expanded to retailers like Target, Sephora, and Nordstrom.
AGIRAILS built ACTP for the transaction ACP leaves to others: one agent paying another for work. The buyer agent's USDC enters a contract before the work starts. When the provider finishes, it commits a delivery hash on-chain, which opens a dispute window. The buyer's approval or silence releases the funds, and the settlement writes to the provider's ERC-8004 record, the Ethereum standard for agent identity and reputation. No human confirms anything, because there is no human in the transaction; the contract carries the trust instead.
Is AGIRAILS the same as ACP?
No, and the acronym is doing most of the confusing. ACP standardizes how a merchant sells to a human whose agent is doing the shopping: catalog, checkout session, delegated card credential, order webhooks. ACTP standardizes how two agents exchange value for work: escrow, attestation, disputes, reputation. They do not share a buyer, a rail, or a failure mode. The one thing they share is a design instinct: both publish under Apache-2.0, ACP its spec, ACTP its contracts and SDK. Both also leave the existing system of record where it is: ACP with the merchant, ACTP with the chain.
What is the difference between AGIRAILS ACTP and Stripe ACP?
The transaction belongs to different parties: an ACP purchase belongs to a human, with the agent fronting it; an ACTP transaction belongs to the agents on both ends.
That split decides everything downstream. In ACP the sign-off is human and the credential is the human's card, chargeable once, within limits. The protocol moves messages, not money: no new party holds funds in flight, because authorization and settlement stay where retail already keeps them. On ACTP the funds move first and sit in a contract while the work happens. There is no card, no processor, and no one to sign off partway through; release is a state transition against the committed delivery hash.
The second split is what happens when the transaction goes wrong. ACP records problems and routes them to the people who already own them. The order model carries an adjustment type for disputes, which covers chargebacks, and the merchant handles fulfillment and support as it does for any other order. A chargeback runs in somebody else's system, the processor's and the card network's, and for a human purchase that system works. ACTP has no such landlord, so the dispute lives in the protocol: either side can challenge by posting a bond, so frivolous disputes cost money; AI arbiters rule first, appeals stay bonded, and UMA's optimistic oracle, a neutral dispute layer from DeFi, settles it on-chain.
The third split is memory. ACP's spec has no identity or reputation layer for agents; the discovery RFC defers agent identity as a separate concern. That is coherent: the merchant knows the human through the card, so the trust rides on the cardholder's credential, and the agent needs no protocol-level track record of its own. On ACTP the agent is the counterparty, so the protocol keeps score: every settled job lands on the provider's ERC-8004 record, because next time, some other agent will need to know.
The words "escrow" and "agent-to-agent" appear zero times in ACP's repository, and that is not an oversight. Stripe's own documentation sorts the territory into two shelves: selling through agents (ACP, alongside Google's UCP) and machine payments (MPP and x402). ACTP lives on the second shelf, in the corner those standards leave open: machine work that takes time and needs more than an instant transfer.
Side by side
| Criterion | AGIRAILS ACTP | ACP (OpenAI/Stripe) |
|---|---|---|
| Kind of thing | Settlement protocol between agents; contracts on Base (Coinbase's Ethereum L2) | Checkout standard between a human's agent and merchants |
| The question it answers | What settles the account between two working agents? | How does a person's agent check out at a real store? |
| Who transacts | Two agents, buyer and provider, in their own names | Human buyer, through an agent, with a merchant |
| The human's role | None at transaction time | Confirms the purchase; the card is theirs |
| What moves through it | Escrowed USDC, from commit to settlement | Catalog data, checkout sessions, one scoped card token |
| Funds in flight | In on-chain escrow | With no new party; the merchant's processor charges the card as usual |
| Recourse | Challenge with a bond; the ruling ends on-chain (UMA backstop) | Merchant support plus card-network machinery; the order model reports disputes |
| Agent identity and reputation | ERC-8004; every settlement updates the record | Out of scope; agent identity deferred as a separate concern |
| Fees | 1% on each settlement ($0.05 floor); network (gas) fees sponsored by AGIRAILS | OpenAI charges merchants "a small fee on completed purchases"; no published schedule |
| Governance | Everything shipped under Apache-2.0; one company, AGIRAILS Inc, maintains the protocol | Apache-2.0; OpenAI and Stripe as Founding Maintainers, Meta on the TSC |
| Status | Live on Base mainnet; the first agent-to-agent escrow settlement is public on BaseScan (February 2026) | Spec in beta, releases through April 2026; Etsy live at launch, major retailers in discovery |
What people conflate about AGIRAILS and ACP
"ACP and ACTP are the same protocol." Two standards, and the full names untangle them: searching the Agentic Commerce Protocol vs the Agent Commerce Transaction Protocol is asking which side of the counter the agent stands on. ACP is the OpenAI/Stripe standard that lets a shopper's agent check out at real stores; coverage shorthands it to Stripe ACP or OpenAI ACP depending on which half is in view, and both names mean the same spec. ACTP is the AGIRAILS settlement rail for agents paying each other.
"OpenAI killed ACP in March 2026." OpenAI retired Instant Checkout, the in-chat purchase surface in ChatGPT, and moved buying into connected merchant apps. The protocol kept going: OpenAI said so at the time, the spec cut a new release the following month, and Stripe kept expanding its Agentic Commerce Suite through the spring. A product surface changed; the standard under it did not.
"ACP covers agent payments, so it covers agents paying agents." ACP's payment spec exists to move a human's card credential into a merchant charge without exposing it; its stated scope stops there. When Stripe's docs talk about machines paying for services programmatically, they point to different standards. Machine-to-machine work is not a gap in ACP; it is a different economy, and it is the one ACTP settles.
Can AGIRAILS and ACP work together?
They can coexist without touching, and that is the likely shape: ACP in the shopping half of an agent's life, ACTP in the working half. The clean composition shows up when commerce turns into labor. A retailer that sells through ACP still has to run the machine side of its business, and the agents doing that work (a catalog-enrichment agent, a translation agent, a logistics optimizer) are counterparties, not checkouts. Those legs need committed funds, proof of delivery, and a dispute path, which is ACTP's half of the map.
Is AGIRAILS an ACP alternative for agent payments?
Not for shopping. If a human is buying from merchants through an agent, ACP is the standard built for that exact job, and ACTP does not try. For agents paying agents, the roles reverse: ACP's spec has nothing on that page, and ACTP is the settlement layer built for it. The two protocols are alternatives only in a sentence that confuses their acronyms.
When should I use AGIRAILS instead of ACP?
If there is a cart, it is ACP. If there is a counterparty, it is ACTP.
Use ACP if:
- a human is buying goods or services from real merchants, with an agent assembling the purchase
- the buyer's card should stay the credential, vaulted into a scoped single-use token
- merchants need to keep their existing processor, fulfillment, and support flows untouched
- you want discovery through product feeds that AI surfaces can read
- your platform integrates with the OpenAI and Stripe agentic commerce stack
Use AGIRAILS if:
- nobody at either end can click Confirm, because both parties are software
- funding is the first step of the job, not the last
- problems need a resolution path that lives in the protocol, not in a support inbox
- the agent itself needs a track record that other agents can check
- the work is a service or an outcome, not an item with a shipping address
Where this connects
The mechanism that replaces the confirming human: What is agent escrow?
Why an agent transaction cannot borrow retail's system of record: Why don't traditional payment processors work for AI agents?
The delegated-spending platform comparison, one layer up from checkout: AGIRAILS vs Nevermined
The rest of the series, mapped: AGIRAILS comparisons
The protocol on the other side of this page: agirails.io
Sources and verification
Last verified: July 2, 2026.
Primary ACP sources used for this comparison:
- agenticcommerce.dev: the standard's definition, PSP openness, Apache-2.0 licensing.
- agentic-commerce-protocol on GitHub (checked at commit c2afc86): the RFCs, the 2026-04-17 spec release, MAINTAINERS and governance, and the word-frequency checks cited above.
- The Delegate Payment RFC: scoped vault tokens, "payments, settlement, and compliance remain on the merchant's rails."
- OpenAI's Instant Checkout launch post (September 2025): the merchant fee framing and the merchant-of-record model.
- Stripe's agentic commerce documentation: Shared Payment Tokens and the four-protocol map (UCP and ACP for selling through agents; MPP and x402 for machine payments).
ACP walks a human's agent into stores that already exist. ACTP is where agents do business with each other, trust built into the rail. One letter apart, and the economy needs both: people will keep shopping, and their agents will keep hiring.