What Is Agentic Commerce Protocol (ACP)? Salesforce Commerce Cloud, B2B, B2C and Shopify Guide

The paradigm of digital commerce is undergoing its most radical transformation since the transition from desktop websites to mobile shopping apps. Historically, ecommerce systems were designed for human eyeballs: visual storefronts, clickable menus, form fields, and multi-step manual checkouts.

However, in 2026, the primary buyer is shifting. Autonomous AI shopping agents-powered by advanced Large Language Models (LLMs) and tools like ChatGPT-are acting as intermediaries between human intent and the final purchase. This paradigm is known as agentic commerce.

To bridge the gap between machine-readable operations and legacy ecommerce systems, OpenAI and Stripe introduced the Agentic Commerce Protocol (ACP). This open standard is transforming how businesses sell products online. This business readiness guide explains how the protocol works, its implications for Salesforce Commerce Cloud and Shopify stores, and how you can prepare your technology stack for a future where machines make transactions.

---

1. What Is Agentic Commerce Protocol (ACP)?

The Agentic Commerce Protocol (ACP) is an open-source, standardized specification co-developed by OpenAI and Stripe. It defines a secure, machine-readable interface through which autonomous AI agents can search for products, verify inventory levels, retrieve dynamic pricing, configure checkout sessions, and safely authorize payments.

Instead of relying on web scraping or rigid custom APIs, ACP provides a unified API design. This standard allows any compliant AI agent (such as ChatGPT, Anthropic's Claude, or custom enterprise agents) to negotiate and execute checkouts directly with any compliant ecommerce platform. It shifts the commerce interface from visual pixel layouts to highly structured JSON payloads, allowing transaction-based agentic operations.

---

2. Why Agentic Commerce Matters in 2026

In 2026, AI shopping agents are no longer just product recommendation chatbots. They have evolved into autonomous assistants capable of executing transactions on behalf of users.

This change is driven by three main factors:

• The Death of Search-and-Browse: Buyers no longer want to browse dozens of websites, filter lists, and compare specifications. They ask their AI agent to find, analyze, and purchase the best option.
• Unified Checkout Experiences: Customers expect to buy items within their conversational thread (e.g., ChatGPT Instant Checkout) without being redirected to third-party storefronts.
• AI Agents as a Sales Channel: For merchants, optimizing for AI crawlers and agent checkouts is just as critical as legacy SEO and mobile conversion optimization. If your store cannot communicate with an AI agent structurally, you will lose sales to competitors who can.

---

3. How ACP Works Step by Step

The execution of a purchase under the Agentic Commerce Protocol follows a structured, asynchronous sequence of steps:

sequenceDiagram
    autonumber
    actor User
    participant Agent as AI Agent (ChatGPT)
    participant ACP as ACP Gateway / Merchant API
    participant Commerce as Commerce Engine (Salesforce/Shopify)
    participant Stripe as Payment Provider (Stripe)

    User->>Agent: "Buy a red leather jacket under $200"
    Agent->>ACP: Query Products (GET /products)
    ACP->>Commerce: Fetch Catalog & Inventory
    Commerce-->>ACP: Return matching items
    Agent->>User: "I found this jacket. Should I buy it?"
    User->>Agent: "Yes, go ahead."
    Agent->>ACP: Create Checkout Session (POST /checkout)
    ACP->>Commerce: Create Draft Order, Calculate Tax/Shipping
    Commerce-->>ACP: Return Checkout Details & Total Price
    Agent->>Stripe: Request Payment Tokenization
    Stripe-->>Agent: Secure Payment Token (Ephemeral Key)
    Agent->>ACP: Authorize & Complete Order (POST /checkout/complete)
    ACP->>Stripe: Process Payment (Charge)
    ACP->>Commerce: Confirm & Finalize Order
    ACP-->>Agent: Order Confirmation (ID, Delivery Date)
    Agent-->>User: "Ordered! Delivery expected Friday."

1. Product Discovery: The AI agent queries the merchant's endpoint (typically /products or a configured product feed index) to retrieve structured metadata, variants, real-time pricing, and stock status.
2. Checkout Creation: The agent initiates a checkout session by sending a POST request containing variant IDs, quantities, and the buyer's shipping address to the /checkout endpoint.
3. Dynamic Calculations: The merchant's commerce engine calculates tax, shipping options, and applicable promotions, returning a detailed summary of costs.
4. Tokenized Payment Exchange: Using secure frameworks co-engineered with Stripe, the agent collects payment credentials (already stored securely in the user's AI wallet) and requests an ephemeral payment token.
5. Authorization & Execution: The agent submits this secure payment token back to the merchant's payment capture API. The merchant processes the transaction, locks the inventory, and generates an order ID.
6. Fulfillment & Confirmation: The merchant responds with a standardized order confirmation object, which the AI agent renders as a clean card for the human buyer.

---

4. ACP vs Traditional Ecommerce Checkout

Traditional ecommerce checkout is heavily visual and relies on human intervention. The user clicks buttons, fills out forms, views redirects, and navigates through steps.

ACP eliminates these visual steps. Instead of loading heavy Javascript bundles, CSS styling, and visual banners, the checkout process is a series of secure API calls. The table below highlights the differences between these two approaches:

---

5. ACP vs UCP vs MCP vs AP2

As the agentic web matures, multiple protocols are emerging. It is important to understand how ACP differs from other specifications:

• ACP (Agentic Commerce Protocol): Specifically designed for transactional checkout, payments, pricing, and orders. It was co-developed by OpenAI and Stripe.
• UCP (Universal Commerce Protocol): An initiative backed by Shopify and Google to unify product schema feeds and merchant catalogs for AI crawlers, serving as the data discovery layer that feeds into ACP checkout systems.
• MCP (Model Context Protocol): Developed by Anthropic, Model Context Protocol is a general-purpose protocol designed to connect LLMs to data sources and tools (like databases and CLI utilities), rather than a specific commerce-handling standard.
• AP2 (Agent Protocol 2.0): A generic execution framework for agent-to-agent communication, whereas ACP is specialized for merchant-to-agent retail operations.

---

6. What ACP Means for Salesforce Commerce Cloud

Salesforce Commerce Cloud (SFCC) is the backbone of global enterprise retail. For Salesforce customers, adopting ACP represents a major architectural shift.

To prepare for ACP, organizations must move away from rendering pages server-side and instead build API-first storefronts. Exposing Salesforce Composable Commerce APIs (powered by Commerce API and SCAPI) allows AI agents to interact with Salesforce.

Crucially, Salesforce's native Agentforce Commerce uses agentic reasoning to navigate these endpoints. Exposing ACP-compliant endpoints allows Salesforce merchants to plug directly into external agent networks like OpenAI’s ChatGPT. This turns Salesforce from a destination website into an automated transaction engine.

To implement this transition smoothly, development teams require deep expertise in Composable Commerce, Apex API development, and secure OAuth management. This is where AI-Accelerated Salesforce Development from Intellectual Clouds helps brands design, build, and test ACP integrations faster.

---

7. Salesforce Commerce Cloud B2C Use Cases

For B2C retail, ACP simplifies the path to purchase:

• Conversational Re-orders: A customer tells ChatGPT, "Order the same shampoo I bought last month." The agent queries the Salesforce order history API, checks current stock levels, generates the checkout, and completes the purchase.
• Contextual Upselling: If a buyer searches for a new phone, the AI agent dynamically retrieves product variant accessories (e.g., cases, chargers) directly from Salesforce Commerce Cloud, applying B2C promotions in real time.
• Frictionless Promo Engine: Salesforce promotions are applied programmatically through the cart and checkout API, ensuring the AI agent receives the exact discounted price without human coupon-code typing.

---

8. Salesforce Commerce Cloud B2B Use Cases

B2B agentic commerce is significantly more complex than B2C. Transactions require strict governance, dynamic logic, and enterprise guardrails.

Key requirements for B2B ACP implementation include:

• Account-Specific Pricing: The AI agent must not see public list prices. The agent must authenticate on behalf of a specific corporate buyer role, fetching negotiated contract catalogs.
• Approval Workflows: If an agent creates a purchase request that exceeds spending limits, Salesforce must trigger standard approval flows (e.g., via Salesforce Flow) rather than executing the order immediately. The agent receives a status of Pending Approval.
• Quote-to-Order Integration: AI agents can request quotes for bulk orders. The agent submits a quote request to Salesforce Revenue Cloud, and once sales reps approve it, the agent completes the transaction via ACP.
• Guardrails and Logs: Every action taken by an AI agent must be logged in Salesforce CRM for auditing. This ensures clear records of which LLM initiated a checkout, which user authorized it, and what validation steps were completed.

---

---

9. What ACP Means for Shopify Stores

Shopify is well-positioned for agentic commerce. The platform has championed headless architecture and the Universal Commerce Protocol (UCP), making Shopify storefronts highly accessible to AI agents.

For Shopify DTC brands, the impact of ACP is immediate:

• Pre-site Comparisons: AI shopping assistants compare your product specs, reviews, and prices against competitors before a customer ever visits your website.
• Shopify Checkout Integration: Shopify's checkout engine can integrate with ACP endpoints, allowing developers to route agent checkouts through Shopify Payments (backed by Stripe’s infrastructure).
• Data Cleanliness: To participate, Shopify merchants must maintain highly clean variant configurations, exact inventory counts across locations, and structured shipping/return policies. If your product variants are disorganized, AI agents will fail to process checkout payloads and choose a competitor's store.

---

10. Technical Architecture for ACP-Ready Commerce

To implement an ACP-ready architecture, businesses need a wrapper API that translates standard commerce system models into the ACP specification.

                  ┌──────────────────────────────────────────────┐
                  │          AI Agent (e.g., ChatGPT)            │
                  └──────────────────────┬───────────────────────┘
                                         │
                                         ▼ ACP REST Request (JSON)
                  ┌──────────────────────────────────────────────┐
                  │              ACP Gateway / API               │
                  │        (Auth, Security & Validation)         │
                  └──────────────────────┬───────────────────────┘
                                         │
                   ┌─────────────────────┴─────────────────────┐
                   ▼                                           ▼
      ┌─────────────────────────┐                 ┌─────────────────────────┐
      │  Salesforce Commerce   │                 │     Shopify Engine      │
      │   Composable APIs       │                 │      Storefront API     │
      └────────────┬────────────┘                 └────────────┬────────────┘
                   │                                           │
                   ▼                                           ▼
      ┌─────────────────────────┐                 ┌─────────────────────────┐
      │   Data Cloud / CRM /    │                 │   Shopify Inventory &   │
      │    Order Management     │                 │    Fulfillment APIs     │
      └─────────────────────────┘                 └─────────────────────────┘

The gateway handles:

1. Authentication: Exchanging user session keys for secure OAuth tokens.
2. Translation: Mapping Salesforce Apex REST responses or Shopify Storefront API queries into standard ACP schemas.
3. Session State: Maintaining temporary checkout status tokens so the agent can modify cart contents (e.g., changing quantity or shipping method) before executing the final purchase.

---

11. Product Feed, Inventory, Pricing and Checkout Requirements

Machines require highly structured, real-time data to complete purchases. Key considerations for your product feeds and checkout flows include:

• Variant-Level Data: Feeds must specify exact attributes (color, size, material, SKU) for every product. Visual-only options on a web page are unreadable by AI agents.
• Real-time Inventory: If a product is out of stock, the API must report it instantly. AI checkout sessions fail if payment is authorized for an unavailable item.
• Accurate Shipping and Tax Rules: Checkout endpoints must return precise shipping quotes and sales tax calculations based on the recipient's address. Estimations or flat rates can lead to reconciliation issues.
• Returns & Shipping Policies: Return policies must be formatted using structured schema files (e.g., AEO guidelines) so the agent can explain the terms to the buyer.

---

12. Security, Payment, Consent and Governance Risks

Deploying autonomous purchasing protocols introduces critical security challenges:

• Payment Tokenization: Credit card details should never pass through the AI agent in plaintext. The agent requests a secure token from Stripe, and only this token is submitted to the merchant.
• Spending Limits and Consent: Human confirmation is required before final payment execution. The protocol enforces a step where the agent presents the total cost and requests the user's explicit consent.
• LLM Prompt Injection and Fraud: Attackers may attempt to inject malicious instructions into product reviews to manipulate AI buying decisions. Order validation engines must verify that catalog pricing matches the final charged amount to prevent fraud.

---

13. AISEO: How to Make Products Discoverable by AI Agents

Before an agent can buy your products, it must find them. AI Search Engine Optimization (AISEO) and Answer Engine Optimization (AEO) are critical:

1. Inject Structured Schema Markup: Every page must include rich JSON-LD data for Product, Offer, and Organization. Use guidelines for formatting content for AI crawlers to help crawlers parse your site.
2. Build Knowledge Graphs: Link products to specific brands, compatibility charts, and attributes. Creating knowledge graphs for AI ensures LLMs understand the relationship between different items in your catalog.
3. Maintain Semantic Content: Describe products in natural language, detailing exact specifications and use cases, allowing AI systems to match your products with conversational user queries.

---

14. ACP Readiness Checklist

Use this checklist to assess your organization's readiness for the Agentic Commerce Protocol:

• [ ] Clean Product Catalog Data: All SKUs have clear variant attributes (size, color, material, weight) and structured descriptions.
• [ ] JSON-LD Schema Implementation: Product, Offer, and FAQ schemas are active on all product detail pages (PDPs).
• [ ] API-First Composable Commerce: Headless endpoints (Salesforce Composable APIs or Shopify Storefront API) are open and responsive.
• [ ] Real-time Inventory Sync: Inventory updates are synchronized across channels, preventing out-of-stock checkouts.
• [ ] Payment Tokenization: Store supports modern Stripe or equivalent payment gateways capable of processing tokenized checkout requests.
• [ ] B2B Guardrails (If Applicable): Contract catalogs, dynamic pricing, and approval flows are managed programmatically via APIs.
• [ ] AI-Friendly Crawler Policies: Robots.txt permits LLM search crawlers (e.g., GPTBot) to access product schemas.

---

15. How Intellectual Clouds Helps with AI-Accelerated Salesforce Commerce

Transitioning to agentic commerce requires updating APIs, cleaning product feeds, and integrating CRM workflows.

At Intellectual Clouds, we specialize in Salesforce Consultancy and AI-Accelerated Salesforce Development. We help ecommerce brands adapt to these changes:

• API Development: We build and optimize Apex REST gateways to map Salesforce Commerce Cloud data to the ACP specification.
• AISEO and Catalog Optimization: We structure your catalog data, build robust knowledge graphs, and implement advanced SEO metadata to make your products easily discoverable by AI engines.
• B2B Complex Workflows: We configure Salesforce Flows, contract pricing APIs, and approval guardrails to ensure secure agentic transactions.
• End-to-End Integrations: We connect Salesforce with Stripe and OpenAI agent interfaces to enable secure conversational checkouts.

---

16. FAQs

1. What is Agentic Commerce Protocol?

Agentic Commerce Protocol (ACP) is an open API standard that enables autonomous AI shopping agents to discover products, set up checkouts, and complete payments securely on digital commerce platforms.

2. Who created ACP?

The protocol was co-developed by OpenAI and Stripe, design-built to connect conversational LLM interfaces with modern transaction and payment systems.

3. How does ACP work?

The AI agent queries product feeds, sends checkout details (items, addresses) to the merchant's endpoint, receives taxes/shipping quotes, requests a secure payment token from Stripe, and completes the purchase via API.

4. Is ACP only for ChatGPT?

No. ACP is an open standard. Any AI assistant, developer, or platform (including Anthropic’s Claude, Google's Gemini, or custom enterprise agents) can use it to complete transactions with compliant merchants.

5. What is the difference between ACP and UCP?

Shopify’s Universal Commerce Protocol (UCP) focus is on unifying product catalog data structure for search crawlers. ACP focuses on the transaction layer-managing checkout sessions, tax calculations, and payments.

6. How does ACP affect Salesforce Commerce Cloud?

It requires Salesforce merchants to expose headless APIs (Salesforce Composable Commerce) through secure gateways, allowing agents to fetch catalogs and complete purchases programmatically.

7. Can ACP work for B2B ecommerce?

Yes, but B2B requires extra guardrails, such as account-specific contract pricing, quote-to-order APIs, spending limits, and approval workflows managed in the CRM.

8. Can Shopify stores use agentic commerce?

Yes. Shopify's API-first storefront architecture and integration with payment systems like Stripe make Shopify stores highly compatible with agentic checkout protocols.

9. What data does an AI shopping agent need?

AI agents require structured, machine-readable data, including SKU variant attributes, real-time inventory levels, shipping rules, tax calculations, and return policies.

10. How can Intellectual Clouds help ecommerce brands prepare for ACP?

Intellectual Clouds provides specialized AI-accelerated Salesforce development and consultancy, building ACP API gateways, mapping catalogs, and configuring secure CRM validation guardrails.

---