ACP vs UCP vs haggl.ai: Comparing the Protocols Powering Agentic Commerce

Three protocols are shaping how AI agents buy things online. They’re not competitors—they solve different parts of the same problem. Here’s how they fit together.

The agentic commerce stack is being built layer by layer. OpenAI and Stripe launched their Agentic Commerce Protocol. Google introduced the Universal Commerce Protocol. And haggl.ai added a negotiation layer that neither of them covers. Understanding what each does—and what they don’t—is essential for vendors deciding how to sell to AI agents.

This post breaks down each protocol’s architecture, limitations, and practical role. We’ll show you how they work together, and help you decide which to implement.

The Agentic Commerce Protocol (ACP) — OpenAI + Stripe

What it is

The Agentic Commerce Protocol is an open standard published under Apache 2.0 license and jointly governed by OpenAI and Stripe. It defines how AI agents discover products, add items to carts, and complete transactions. Since September 2025, it’s been live in ChatGPT, meaning any vendor implementing ACP becomes purchasable directly within the ChatGPT interface.

What it handles

ACP covers three core flows:

• Product discovery: Agents find your products and services via embeddings and semantic search
• Checkout flows: Standard cart, billing, and shipping information collection
• Payment processing: Integration with Stripe (and other processors) to handle authorization and settlement

Technical details

ACP uses date-based versioning (the latest releases are 2026-01-16 and 2026-01-30). It’s a REST API-based protocol with thoughtful features:

• Capability negotiation: Merchants declare which payment methods, shipping regions, and discount types they support
• Extension framework: Custom fields and dynamic pricing can be added without breaking the spec
• Multiple payment handlers: Works with Stripe, but extensible to other processors

A typical ACP integration involves hosting an endpoint that responds to agent queries about product availability, pricing, and payment options.

Best for

Merchants selling physical products, SaaS, or digital goods who want their catalog available inside ChatGPT. If your customers use ChatGPT and you want to capture purchases there, ACP is the most direct path.

Key limitation

ACP is transaction-focused: product → cart → pay. It doesn’t handle negotiation or personalized pricing based on the buyer’s profile. If two agents with different budgets and use cases hit your ACP endpoint, they get the same offer.

The Universal Commerce Protocol (UCP) — Google

What it is

Google introduced the Universal Commerce Protocol at the National Retail Federation conference in January 2026. It’s backed by a consortium of retailers (Shopify, Etsy, Wayfair, Target, Walmart) and payment networks (Visa, Mastercard, Stripe), with 20+ additional partners committed to implementation.

UCP is designed to enable commerce across Google’s AI shopping surfaces—Google AI Mode, Gemini, and other agent platforms—without forcing merchants to build separate integrations for each.

What it handles

• Checkout and payments: Order creation and fulfillment
• Identity linking: Connecting agent-based transactions to customer profiles
• Order management: Status updates, returns, customer service integration
• Multi-protocol support: Integrates with REST APIs, MCP (Model Context Protocol), A2A (Agent-to-Agent), and AP2 (Agent Payments Protocol)

Technical details

UCP is more of an umbrella standard than a single protocol. It defines how various sub-protocols (MCP, A2A, AP2) layer on top of REST APIs to enable agent commerce. The specification is published at ucp.dev.

Rather than requiring merchants to write new code for each protocol, UCP aims to be a unifying interface. A vendor implementing UCP correctly can serve agents regardless of which sub-protocol they prefer.

Best for

Retailers who want presence across Google’s AI shopping ecosystem and the broader multi-agent marketplace. If you sell at scale and want your products discoverable by agents across multiple AI platforms, UCP gives you that reach without building multiple integrations.

Key limitation

Like ACP, UCP is catalog-and-checkout-focused. It excels at “what do you sell?” and “how do I complete the purchase?” but doesn’t address “what deal can I negotiate?” The protocol assumes a fixed price; dynamic, personalized offers aren’t part of the spec.

The haggl.ai Negotiation Protocol

What it is

haggl.ai is purpose-built for the negotiation step of agentic commerce—the part of the buying journey that ACP and UCP don’t cover. While those protocols answer “what products do you have?” and “how do I pay?”, haggl.ai answers “what deal can I get based on who I am?”

It’s a complementary protocol, not a replacement. haggl.ai adds a layer on top of the existing stack.

What it handles

• Endpoint discovery: Agents find vendor negotiation endpoints via meta tags (similar to OpenGraph, but for commerce)
• ICP schema exchange: Vendors define what buyer profile information matters to them (industry, company size, current provider, spend, growth rate, etc.)
• Multi-turn negotiation: Agent submits information about the buyer, vendor responds with a personalized offer or counter-proposal
• Proof verification: Agents can include cryptographic proofs (via zkTLS and other methods) that their claims about the buyer are truthful
• Session management: Negotiation context persists across multiple agent requests

Technical details

A haggl.ai negotiation flow is session-based:

1. Discovery: Agent does a GET request to the vendor’s domain, reads meta tags to find the negotiation endpoint and ICP schema
2. ICP submission: Agent sends a structured argument containing the buyer’s profile (name, company, industry, annual spend, etc.) along with optional cryptographic proofs
3. Offer generation: Vendor’s endpoint evaluates the ICP data and returns either:
   • A personalized offer (discount, terms, seat count, etc.)
   • A counter-proposal requesting additional information
4. Verification levels: The vendor can flag each piece of information as dkim_verified (email domain-verified), unverified (agent-claimed), or self_reported (buyer-declared)

Best for

Any vendor who loses deals to competitors because they can’t differentiate on terms. If you want to offer personalized discounts, flexible pricing, and custom terms—all in a structured, agent-readable format—haggl.ai lets you do that at scale.

haggl.ai is especially valuable for:

• Enterprise B2B vendors: Who negotiate with each customer
• SaaS companies: Who offer tiered pricing and want to optimize deals per customer value
• Marketplaces: Who want to attract high-value buyers with better terms
• Any vendor with margin flexibility: Where personalization drives better close rates

Unique advantage: Lead generation as a byproduct

Every negotiation with haggl.ai produces ICP data. You learn:

• The buyer’s company and industry
• Current technology stack and providers
• Estimated spend and growth
• Team size and structure
• Geographic location

This data is structured, verified (or flagged as unverified), and timestamped. You’re building a qualified lead pipeline as commerce happens.

How They Work Together: The Key Insight

These protocols are complementary layers, not competitors. Here’s how the stack works:

• ACP/UCP: Handles discovery and checkout (“Here’s my catalog and payment terms”)
• haggl.ai: Handles negotiation (“Here’s the personalized deal I can offer you”)
• The agent journey: Discover → Negotiate → Checkout

In practice, a vendor can implement all three:

Agent discovers your product (via ACP or UCP)
       ↓
Agent requests negotiation (via haggl.ai)
       ↓
Agent receives personalized offer
       ↓
Agent completes purchase (via ACP or UCP at the negotiated price)

For example, a SaaS company selling at $99/month could:

• List their product on ACP (for ChatGPT discovery)
• Publish on UCP (for Google AI surfaces)
• Implement haggl.ai (to offer enterprise customers $49/month based on their budget and company size)

The agent visits once, follows the entire flow, and closes the deal. The vendor gets a sale at the right price for the buyer’s profile.

Comparison Table

Which Should You Implement?

Quick decision tree:

• “I sell physical products and want to be in ChatGPT” → Implement ACP
• “I want presence across Google AI shopping surfaces” → Implement UCP
• “I want to negotiate personalized deals and capture buyer data” → Implement haggl.ai
• “I want maximum coverage” → Implement all three

For most B2B vendors, the best approach is ACP + haggl.ai or UCP + haggl.ai. The discovery and checkout protocols (ACP/UCP) bring agent traffic to you. haggl.ai converts that traffic into higher-value, personalized deals.

For consumer e-commerce, if you’re multi-channel already, treating ACP and UCP like you treat Shopify and Amazon makes sense: one more inventory feed, one more integration.

For enterprise SaaS, haggl.ai is often the primary integration. You can skip ACP and UCP if your sales motion is primarily agent-negotiated deals.

The Bigger Picture

The agentic commerce ecosystem is still in its early stage. ACP went live in September 2025. UCP was announced in January 2026. haggl.ai is the newest addition.

What’s emerging is clear: no single protocol handles the entire buyer journey. Each solves a specific problem well:

• OpenAI + Stripe solved: “How do agents discover and buy products inside ChatGPT?”
• Google solved: “How do we enable commerce across multiple AI surfaces without fractured integrations?”
• haggl.ai solved: “How do agents and vendors negotiate personalized terms?”

Vendors who understand this architecture and implement strategically will capture disproportionate share of agent-driven commerce. Those who pick one protocol and ignore the others will miss deals.

Next Steps

Ready to add negotiation to your agentic commerce stack?

• Explore the haggl.ai protocol: Visit our technical documentation to see how negotiation works under the hood
• See it in action: Check out our guide to preparing your site for AI agents
• Get started: Our getting started guide shows you how to add an endpoint and start negotiating with agents in minutes

For a deeper dive into why agents need to negotiate, read What is Agentic Commerce?

Questions about how haggl.ai fits with ACP or UCP? Reach out—we’re here to help.