Your engineering team gets a requirement to enable ChatGPT shopping. They ask which API to build. The answer surprises you: multiple protocols, each handling different parts of the transaction. One protocol manages product search and checkout. Another handles how systems connect. A third secures payment authorization. You thought "agentic commerce protocol" was singular. It's not.

AI agents need to work across thousands of merchants without custom integrations for each one. Protocols provide the standardized language that lets agents search products, build carts, process payments, and complete orders across any merchant infrastructure. Without these standards, scaling agentic commerce would require building individual integrations between every agent and every merchant—a technical impossibility at scale.

Multiple protocols emerged in late 2024 to solve different parts of this problem. Understanding which protocol does what helps you determine which teams in your organization need to be involved and what infrastructure changes you'll face.

What agentic commerce protocols do

Before protocols existed, every AI agent needed custom integration with every merchant system. Ten agents working with one hundred merchants meant building one thousand separate integrations. Each integration required engineering resources, ongoing maintenance, and broke whenever either side changed their systems. This created an unsustainable scaling problem known as the N×M problem.

Protocols solve this by standardizing communication. When merchants implement a protocol, any agent that speaks that protocol can interact with their systems. The one thousand custom integrations become one hundred and ten: ten agents implement the protocol, one hundred merchants implement the protocol, and they all work together automatically.

Think of protocols like international shipping standards. Containers come in standardized sizes. Ports worldwide can handle any container that follows the standard. Protocols work the same way: standardized data formats and communication patterns that work across any implementation.

Three categories of protocols emerged to handle different aspects of agentic commerce. Transaction protocols manage product search, cart operations, and checkout flow. Integration protocols simplify how agents connect to merchant data sources. Payment protocols secure authorization and settlement. Different companies built protocols solving different parts of the problem, which means your infrastructure will likely need multiple protocols working together.

The major agentic commerce protocols

Several protocols launched between October and December 2024, each addressing specific technical challenges. Understanding what each protocol does and who built it clarifies which ones your organization needs.

Agentic Commerce Protocol (ACP)

OpenAI and Stripe built ACP to handle the transaction layer of agentic commerce. Announced in October 2024 with ChatGPT's Instant Checkout feature, ACP defines how agents search products, build carts, and complete orders. The protocol establishes standardized endpoints for product catalog queries, cart operations, checkout sequences, and order confirmations.

When ChatGPT needs to show a customer running shoes, it queries merchant systems using ACP's product search format. When the customer decides to buy, the agent uses ACP's cart and checkout endpoints to complete the purchase. Merchants receive order data in a predictable format regardless of which agent initiated the transaction.

Shopify integrated ACP across its entire platform, enabling over one million merchants to accept ChatGPT orders automatically. Etsy followed quickly. This gave ACP the fastest market adoption of any agentic commerce protocol because merchants didn't need to build custom implementations—the platform handled it.

Without proper ACP implementation, agents query your products but receive incomplete specifications. ChatGPT asks for "wireless headphones with active noise cancellation under $200." Your product matches perfectly but your data doesn't specify the noise cancellation type. The agent filters you out. Your competitor with complete attribute data wins the sale.

Model Context Protocol (MCP)

Anthropic built MCP to solve a different problem: integration complexity. Before MCP, every agent needed custom connections to every data source it accessed. If ten agents wanted to work with one hundred different databases, APIs, and business tools, someone had to build one thousand integrations.

MCP creates a middle layer. Agents connect to MCP servers. MCP servers connect to data sources. Now you need ten agent-to-MCP connections plus one hundred MCP-to-data-source connections. The math changes from 1,000 integrations to 110 integrations.

While ACP focuses specifically on commerce transactions, MCP works broadly across any system where agents need data access. This includes databases, analytics platforms, inventory systems, customer data platforms, and business intelligence tools.

Agent Payments Protocol (AP2)

Google built AP2 with over sixty partners including Mastercard, PayPal, Visa, and major banks. Announced in November 2024, AP2 handles the security layer of agent payments through cryptographic mandates.

A mandate is a cryptographically signed contract proving the user authorized the agent to make purchases on their behalf. When an agent completes a transaction, the mandate provides verifiable proof that the customer gave permission. If a customer disputes a charge claiming they never authorized it, the merchant can present the cryptographic mandate as evidence.

This solves a critical problem in agent-driven commerce: proving authorization when the customer never clicked a checkout button or saw a confirmation screen. Traditional e-commerce shows the customer clicked "Place Order." Agent commerce shows an API call. AP2's mandate structure provides the legal proof of authorization that traditional checkout workflows captured through interface interactions.

Trusted Agent Protocol (TAP)

Visa built TAP to focus on identity verification and secure agent authentication. While AP2 handles payment authorization broadly across multiple payment networks, TAP provides Visa-specific implementations with particular strength in markets where Visa has dominant card network position. The protocol emphasizes fraud prevention by verifying that agents are who they claim to be and that user authorization is legitimate.

How agentic commerce protocols work together

These protocols create a stack where each layer handles specific responsibilities. A complete transaction flows through multiple protocols in sequence.

A customer asks ChatGPT for running shoes. The agent queries your catalog through ACP's product search endpoint, comparing specifications from multiple merchants. Your MCP server provides real-time inventory data showing stock levels. The customer selects your product based on the agent's recommendation. ACP initiates checkout and calculates the total. AP2 creates a cryptographic mandate proving authorization. Your system receives the order with verifiable proof of payment authorization. Post-purchase tracking updates flow through ACP's fulfillment webhooks as the order ships.

Discovery happens through MCP when the agent needs access to your product catalog. Your data infrastructure team exposes product data through an MCP server, allowing agents to query inventory, pricing, and specifications through a standardized interface.

Selection happens through ACP when the agent searches products and compares options. Your e-commerce team ensures product data meets ACP format requirements so agents can parse specifications, filter by attributes, and match products to customer intent.

Checkout happens through both ACP and AP2 working together. Your e-commerce team manages the ACP checkout flow—building carts, calculating totals, confirming orders. Simultaneously, your finance team manages payment authorization through AP2 mandates.

Post-purchase happens through ACP's fulfillment and order management endpoints. Your operations team provides tracking updates, handles returns, and manages customer support through standardized interfaces that work regardless of which agent initiated the purchase.

Protocol implementation considerations

Implementing agentic commerce protocols requires changes across technical architecture, data management, and organizational processes. Different teams face different requirements.

Engineering team: Technical requirements

Real-time APIs become mandatory. If your product catalog updates every thirty minutes via batch processing, agents will query stale data. When agents compare your availability against competitors querying real-time systems, your outdated data makes you noncompetitive. Your engineering team needs to rebuild data pipelines for continuous synchronization.

Standardized endpoints must follow protocol specifications. ACP defines specific URL patterns, data formats, and response structures. Custom implementations that deviate from protocol standards won't work with agents. Your engineering team can't improvise—the protocol specifies what /products/search returns, how cart operations work, and what checkout confirmation looks like.

Webhook infrastructure handles asynchronous updates. When orders ship, when tracking changes, when returns get initiated—these events need to push to agents through webhooks rather than requiring agents to repeatedly poll for updates.

Merchandising and content teams: Data architecture requirements

Product catalogs need machine-readable attributes for every item. Not just title and description, but material composition, dimensions, compatibility specifications, use case tags, warranty details, and care instructions. Missing fields mean agents skip your products during queries. "Luxurious comfort" means nothing to an algorithm. "Memory foam, 12-inch thickness, medium-firm density" matches against customer requirements.

Inventory must synchronize in real-time across all channels. If you sell on your website, Amazon, Walmart, and through agents, all four systems need identical availability data simultaneously. Your operations team needs unified inventory management rather than platform-specific systems that sync periodically.

Pricing can't have platform-specific variations. When agents compare your product at $49.99 on your site versus $54.99 in a retailer feed, they flag the discrepancy and may reject the transaction.

Data and analytics teams: Event capture requirements

Event streams need to capture agent interactions differently than traditional analytics. Traditional analytics track page views, clicks, and cart events. Agent transactions show API calls with no browsing behavior. Your data team needs new instrumentation capturing agent queries, comparison logic, and decision factors that influenced purchases. This requires first-mile data infrastructure that works across protocol implementations, not just traditional web analytics.

Legal, compliance, and finance teams: Security requirements

API authentication verifies agent requests. Not every system claiming to be ChatGPT is actually ChatGPT. Your security team needs authentication mechanisms confirming which agents can access your systems and rate limiting preventing abuse.

Mandate verification prepares for payment disputes. When customers claim they didn't authorize purchases, AP2 mandates provide cryptographic proof. Your finance team needs dispute resolution processes that can present these mandates as evidence.

Consent tracking becomes complex when agents mediate transactions. Traditional e-commerce shows the checkbox customers clicked for marketing emails. Agent-driven commerce shows an API call with no visible consent interface. Your legal and compliance teams need frameworks proving consent was captured even when you didn't control the checkout interface.

Platform and architecture teams: Integration decisions

If you're on Shopify, ACP works automatically. The platform implemented protocol support, and you inherited the capability. Your team focuses on data quality rather than technical implementation.

If you have custom infrastructure, you're building protocol endpoints from scratch. Your engineering team faces months of development implementing ACP product search, cart management, checkout flows, and order management. Each protocol adds similar complexity.

If you use multiple payment processors, you need AP2 support or Stripe's Shared Payment Token API. Processors that don't support agent payment protocols force you to either switch processors or build abstraction layers translating between your existing infrastructure and protocol requirements.

The integration question becomes strategic: do you implement protocols directly, migrate to platforms that handle them, or build abstraction layers supporting multiple protocols? This decision involves engineering, finance, and business strategy teams.

The protocol landscape

Protocol standards launched rapidly in late 2024. Multiple protocols solving adjacent problems creates fragmentation that will likely consolidate as market leaders emerge. Platform power influences protocol adoption more than technical merit. When Shopify enabled ACP for one million merchants automatically, ACP gained distribution advantage regardless of whether competing protocols had superior architecture. Build flexibility into your architecture—the protocols you implement today may need to interoperate with new standards that don't exist yet.

Building for multi-protocol commerce

Protocols make agentic commerce technically feasible by standardizing communication between agents and merchant systems. You'll implement multiple protocols—ACP for transactions, MCP for integrations, AP2 or TAP for payments—with each handling a different layer of the stack. Implementation depends on your existing infrastructure. Platforms like Shopify abstract protocol complexity automatically. Custom stacks require direct implementation across engineering, data, operations, and finance teams.

The organizational challenge extends beyond protocol implementation. Your infrastructure needs capabilities that work regardless of which protocols you support or which new protocols emerge. Event-level data capture, consent enforcement, and identity resolution must function whether transactions happen through ACP, direct API calls, or traditional checkout flows. Companies like MetaRouter build first-mile data infrastructure specifically for this challenge—capturing behavioral signals at origin, embedding compliance metadata at the event level, and maintaining unified customer identity across agent-driven and traditional channels. This protocol-agnostic approach adapts as standards evolve without requiring infrastructure rebuilds.

The question isn't whether to implement agentic commerce protocols but how quickly you can deploy them. Agents are live. ChatGPT has 800 million weekly users. Amazon Rufus is processing billions in influenced purchases. The protocols exist and major platforms have already integrated them. The only variable is whether your systems speak the language agents require and whether your data infrastructure can capture the signals that traditional analytics miss when discovery happens in conversational environments you don't control.

‍