ACP: Protocol Hub

Complete guide to the ACP protocol for agentic commerce: scope, API model, implementation checklist, and best practices.

eLLMo AI Protocols Team

12 min read

ACP Agentic Commerce Checkout Transaction Orchestration Protocol Standards

Short orientation

When customers complete a purchase through an AI assistant, the checkout must respect your pricing, promotions, and policies. When each platform uses a different integration, you spend more time maintaining connections than growing sales. This page is for engineering teams and commerce leaders implementing the Agentic Commerce Protocol (ACP) to enable agent-driven checkout and transaction orchestration without replatforming. It explains ACP's scope and primitives, provides an architecture and API model suitable for translation-layer deployments, and includes an implementation checklist, anti-patterns to avoid, and links to related standards (UCP, MCP, A2A, AP2). The guidance aligns with eLLMo AI's protocol-first, governance-forward approach.

Definition of ACP

The Agentic Commerce Protocol (ACP) standardizes how AI agents coordinate commerce actions, especially checkout and transaction execution, with merchant systems. ACP complements discovery and capability exchange layers by specifying interoperable flows and data structures for carts, offers, sessions, payments, and post-purchase updates. In eLLMo AI's protocol model, ACP is a transaction orchestration layer that works alongside MCP (capability and context), UCP (catalog and commerce objects), and A2A (cross-agent delegation).

References: Agentic Commerce Protocol Landscape 2025-2026 (eLLMo AI); API-first vs protocol-first for agentic commerce (eLLMo AI).

Protocol scope and primitives

ACP addresses the "decision-to-purchase" and "post-purchase" windows in agentic workflows.

Core primitives (object model)

Overview of ACP object types and their roles.

CatalogReference

Linkage to upstream product truth (product ID, variant, attributes). Often sourced from UCP-like catalog or your PIM or feeds.

Offer

Price, currency, promotions, constraints, validity window. Supports dynamic pricing and policy constraints.

LineItem

Selected product plus quantity and per-line adjustments. References Offer and CatalogReference.

CheckoutSession

Single source of truth for the in-progress purchase. Contains shipping, tax, totals, and consent artifacts.

PaymentAuthorization

Scoped authorization (amount, currency, expiry). Typically coordinated with a payments protocol (e.g., AP2).

Order

Immutable record once session completes. Includes fulfillment state and tracking.

PolicyHook

Guardrails for returns, age verification, and regional limits. Enforced during offer and session evaluation.

Event/Webhook

Asynchronous notifications (order.created, fulfillment.shipped). Drive post-purchase experiences.

Idempotency/Correlation

Deduplicate and trace interactions. Required for reliable agent workflows.

Example: minimal CheckoutSession (JSON)

{
  "id": "chk_01HXYZ",
  "status": "requires_payment",
  "line_items": [
    { "sku": "SKU-123", "variant_id": "VAR-456", "quantity": 2, "offer_id": "off_789" }
  ],
  "pricing": {
    "subtotal": {"amount": "480.00", "currency": "USD"},
    "discounts": [{"code": "WELCOME10", "amount": "48.00"}],
    "tax": {"amount": "34.56"},
    "shipping": {"amount": "0.00", "service": "ground"},
    "total": {"amount": "466.56", "currency": "USD"}
  },
  "shipping_address": {
    "name": "A. Rivera",
    "line1": "123 Main St",
    "city": "Austin",
    "region": "TX",
    "postal_code": "78701",
    "country": "US"
  },
  "consents": [{"type": "tos", "version": "1.4", "granted_at": "2026-02-19T18:22:31Z"}],
  "capabilities": ["discounts", "gift_message"],
  "correlation_id": "acf80c77-3bda-4cd6-8bcb-1a91f7b2e320"
}

Webhook event example

{
  "id": "evt_01ABCD",
  "type": "order.fulfillment.shipped",
  "created": "2026-02-20T12:04:54Z",
  "data": {
    "order_id": "ord_01LMNO",
    "carrier": "UPS",
    "tracking_number": "1Z999AA10123456784",
    "estimated_delivery": "2026-02-24"
  },
  "correlation_id": "acf80c77-3bda-4cd6-8bcb-1a91f7b2e320"
}

Architecture and API model

ACP in a translation-layer architecture (no replatforming): an AI agent sends ACP messages (HTTP/JSON) to an ACP Protocol Gateway that handles consent, policy hooks, capability negotiation, brand graph, and auditing. The gateway maps to your existing stack (e.g., Shopify, WooCommerce, custom) and talks to CMS, PIM, OMS, and PSP for catalog, inventory, pricing, and payments.

Diagram showing AI agent communicating with an ACP gateway that translates to existing commerce APIs.

ACP Protocol Gateway: Layered Architecture

Common endpoints

Standard ACP endpoints for health, capabilities, checkout, and orders.

GET /acp/health

Liveness and readiness for agent callers.

GET /acp/capabilities

Enumerate supported flows (discounts, gift, split-ship, etc.).

POST /acp/checkout

Create CheckoutSession from line items and preferences.

PATCH /acp/checkout/{id}

Update addresses, shipping, offers, notes.

POST /acp/checkout/{id}/authorize

Create PaymentAuthorization (often via AP2).

POST /acp/checkout/{id}/complete

Convert session to Order.

GET /acp/orders/{id}

Retrieve order details and status.

POST /acp/webhooks

Event intake (if your system consumes upstream events).

Capability negotiation (example)

{
  "merchant_id": "m_123",
  "capabilities": {
    "shipping": ["ground", "2-day"],
    "discounts": ["code", "auto"],
    "payments": ["card_token", "wallet_token"],
    "post_purchase": ["returns_portal", "partial_cancellation"]
  },
  "policy_versions": {
    "tos": "1.4",
    "returns": "2.1"
  }
}

Sequence: checkout session flow

Typical flow: Agent POSTs to create checkout; gateway creates cart, price, tax; gateway returns CheckoutSession (requires_payment). Agent POSTs to authorize; gateway reserves inventory and creates PaymentAuthorization; returns authorized. Agent POSTs to complete; gateway creates Order; returns order_id and status completed.

Sequence diagram depicting create session, update, and complete purchase interactions across Agent, ACP Gateway, and Backend.

ACP Checkout Session Flow (Sequence)

Implementation checklist

Your roadmap to AI-first commerce

Readiness and mapping

Map product truth to a CatalogReference (SKU, variant, attributes, media). Define Offer logic (promotions, taxes, shipping matrices, currency rules). Identify policy hooks (age-gating, returns windows, regional restrictions).

Gateway and data plane

Stand up an ACP gateway (reverse proxy or service) with idempotency and correlation IDs. Implement /acp/health and /acp/capabilities for conformance and discovery. Implement CheckoutSession create/update/complete with robust validation. Integrate PaymentAuthorization via your PSP; align with AP2-like scoping and expirations. Implement Webhook sender for order and fulfillment events.

Security, governance, and QA

Enforce consent and least privilege on every step; log consent artifacts to the brand graph. Implement RBAC, rate limits, and structured error handling (retryable vs terminal). Add end-to-end test flows (happy path, stale offer, partial stock, network retry).

Operations

Set canonical URL and 301s; publish breadcrumbs. Instrument metrics (latency, error rates, conversion, auth declines). Enable post-purchase workflows (returns, cancellations, exchanges). Create a runbook: incident, rollback, and key alerts (auth spikes, inventory mismatch).

To stay up to date, follow us on LinkedIn and sign up to our mailing list via our mailing list.

Tip: eLLMo AI can stand up a protocol gateway and distribute verified catalog truth across ACP, UCP, MCP, and A2A in under four hours, without replatforming. See Solutions for Brands.

Common pitfalls and best practices

1:1 endpoint wrapping with no intent semantics

Model checkout, session, and offer as first-class protocol objects; do not just mirror legacy cart endpoints.

Overexposed tools without consent

Gate all sensitive operations behind explicit consent artifacts and scoped authorizations.

Stale catalog truth

Normalize via a single brand graph and keep inventory and pricing fresh (short TTLs, event-driven updates).

Ignoring post-purchase

Implement returns and cancellation surfaces; expose order.status via API and webhooks.

Weak observability

Use correlation IDs across agent, gateway, and backend; maintain immutable audit logs.

No failure modes for payments

Define clear retry windows, graceful expirations, and rollback of inventory reservations.

Mixed policy sources

Centralize policy hooks and version them; surface versions in capability negotiation.

Related protocols and standards

Model Context Protocol (MCP)

Capability and context exchange; consent and lifecycle.

Read MCP guidance

Spec: modelcontextprotocol.io

Universal Commerce Protocol (UCP)

Catalog and commerce objects; complements ACP at discovery and data layers.

Explore UCP

Spec: ucp.dev

Agent-to-Agent (A2A)

Secure delegation and cross-vendor collaboration.

Review A2A

Spec: agent2agent.info

Agent Payments Protocol (AP2)

Payment delegation and authorization; pairs with ACP checkout authorization.

Spec: ap2-protocol.org

Related internal resources

Protocols hub (parent); Integrations hub; Glossary: Agentic commerce; Blog: API-first vs protocol-first; Blog: Agentic Commerce Protocol Landscape 2025-2026.

FAQs

What problems does ACP solve?

It standardizes checkout and transaction flows so AI agents can complete purchases reliably with merchant systems.

Do I need to replatform to implement ACP?

No. Implement a protocol gateway that translates ACP objects to your existing REST/GraphQL APIs. eLLMo AI provides this translation layer.

How does ACP relate to UCP, MCP, and A2A?

MCP handles capability and context; UCP structures catalog and commerce data; ACP orchestrates checkout; A2A enables cross-agent delegation.

How do I handle payments?

Use a delegated authorization primitive (e.g., AP2-like flows) for scoped, time-bound authorizations and one-time tokens.

How should I prevent stale pricing and inventory?

Event-driven updates and short TTL caches; treat pricing and inventory as rapidly changing truth validated at session create and complete.

What are the minimal endpoints to go live?

Health, capabilities, checkout create/update/complete, order status, and webhook sender.

How do I enforce policy and consent?

Record consent artifacts within the session; block restricted flows until consent and policy checks pass.

How fast can brands launch with eLLMo AI?

Under four hours in typical cases: connect feeds (about 30 min), enrich and verify (about 1 to 2 hours), deploy across protocols.

Entity-relationship style diagram of CheckoutSession, LineItem, Offer, PaymentAuthorization, and WebhookEvent.

ACP Object Model: Core Primitives

Ready to implement ACP?

Get a protocol gateway and verified catalog across ACP, UCP, MCP, and A2A without replatforming.

Schedule a Demo