The Agentic Commerce Stack - Ahnaf Prio, Best Buy

Agentic Commerce represents a shift from autonomous shopping agents to human-in-the-loop AI assistants that help customers navigate their shopping journey, r...

By Sean Weldon

The Agentic Commerce Stack: Protocol Architecture and Evaluation Frameworks for AI-Mediated Retail Transactions

Abstract

Agentic Commerce represents a fundamental architectural shift in AI-assisted retail, transitioning from brittle browser automation to standardized API-based protocols that enable conversational agents to facilitate shopping transactions. This analysis examines the technical infrastructure underlying production AI commerce systems, focusing on five core protocols: Model Context Protocol (MCP), Agent-to-Agent (A2A), Agentic Commerce Protocol (ACP), Universal Commerce Protocol (UCP), and Agentic Payment Protocol (AP2). With shopping-related queries constituting 45% of agent sessions on major conversational AI platforms and market projections indicating growth from $7 billion to $65 billion by 2030, the domain requires rigorous evaluation frameworks to prevent exploitation and ensure production reliability. The findings demonstrate that while human-in-the-loop architectures currently dominate commercial deployments, autonomous payment delegation remains constrained by authorization complexity and liability distribution challenges. This synthesis provides technical guidance for implementing production-grade agentic commerce systems.

1. Introduction

The integration of artificial intelligence into commercial transactions has evolved from experimental browser automation to production-ready conversational assistants deployed across major platforms. Agentic Commerce refers to AI systems that assist or autonomously execute shopping activities throughout the customer journey, encompassing discovery, decision-making, pricing negotiation, fulfillment coordination, and post-purchase support. Current implementations on platforms including ChatGPT, Google Gemini, Microsoft Copilot, and Meta Shop demonstrate substantial user demand, with 45% of agent sessions involving shopping-related queries.

The shopping experience comprises multiple discrete phases that traditionally require manual customer navigation: discovery (product awareness), decision-making (needs assessment and comparison), loyalty (repeat purchase behavior), pricing (negotiation and optimization), fulfillment (delivery logistics), and post-fulfillment (returns and support). Agentic Commerce introduces AI intermediaries capable of traversing these phases on behalf of users, either through guided assistance or autonomous execution. The fundamental challenge lies in transitioning from human-in-the-loop assistance - where agents provide recommendations requiring manual confirmation - to autonomous shopping agents capable of negotiating prices, comparing merchant offerings, and completing payments without human intervention.

This transition necessitates standardized communication protocols, robust payment authorization mechanisms, and comprehensive evaluation frameworks to ensure reliable production deployment. This synthesis examines the technical architecture underlying Agentic Commerce, analyzing the protocol stack that enables agent-to-merchant communication, payment delegation models, and quality assurance methodologies essential for production systems.

2. Background and Related Work

2.1 Evolution from Browser Automation

Early attempts at shopping automation employed screenshot analysis, Document Object Model (DOM) parsing, and automated form-filling to simulate human browsing behavior. Systems including Chrome extensions and platforms like Atlas represented this first-generation approach. These implementations proved fundamentally brittle: visual interfaces changed frequently, breaking screenshot-based navigation; form-filling triggered merchant security systems designed to detect bot activity; and payment flows actively blocked automated submissions to prevent fraud. The computational overhead of rendering full browser sessions and parsing visual elements introduced latency incompatible with conversational AI response time expectations.

The architectural shift toward API-based commerce eliminated browser impersonation entirely. Rather than simulating human interaction with merchant websites, conversational AI platforms established direct API connections to merchant systems, receiving structured product data and executing transactions through standardized interfaces. This transition enabled the development of competing protocol standards, with OpenAI developing the Agentic Commerce Protocol (ACP) and Google developing the Universal Commerce Protocol (UCP) as foundational primitives for structured commerce communication.

3. Core Analysis

3.1 Protocol Stack Architecture

The Agentic Commerce infrastructure comprises five layered protocols, each addressing distinct functional requirements. The Model Context Protocol (MCP) operates at the capability discovery layer, enabling agents to identify available tools and operations without explicit instruction. In production implementations, MCP allows agents to autonomously select appropriate operations such as product_search based on user intent, eliminating the need for manual routing logic.

The Agent-to-Agent Protocol (A2A) provides standardized specifications for inter-agent communication, enabling customer agents to interact with merchant agents and domain-specific specialized agents. This protocol layer facilitates the multi-agent coordination required for complex shopping scenarios involving multiple merchants or specialized services.

At the data standardization layer, both Agentic Commerce Protocol (ACP) and Universal Commerce Protocol (UCP) provide primitives for structured product information exchange. Rather than requiring web crawling or screen scraping, these protocols enable merchants to proactively deliver product feeds to AI platforms. The architectural decision to use proactive feed delivery rather than search catalog calls addresses computational efficiency: with M merchants and N products, search-based approaches require M×N API calls, whereas pre-indexed feeds reduce overhead through batch processing. Additionally, proactive feed delivery enables retail media ranking considerations, allowing merchants to influence product positioning within agent recommendations.

3.2 Payment Authorization and Delegation

Payment architecture represents the most complex component of the Agentic Commerce stack, balancing user convenience against fraud prevention and liability management. Current production implementations employ distinct approaches: ChatGPT utilizes shared payment tokens that enable transactions across multiple merchants, while Google Gemini restricts payment to Google Pay integration exclusively. Neither platform currently supports fully autonomous payment methods, maintaining human-in-the-loop confirmation as a mandatory step.

The Agentic Payment Protocol (AP2) extends UCP with authorization primitives designed to enable autonomous payment delegation. AP2 tokens specify authorized agent identity, maximum transaction amount, currency constraints, revocation capability, and single-use restrictions. The protocol addresses liability distribution by designating payment processors - rather than merchants directly - as responsible parties for initiating autonomous payments. This architectural decision protects merchants from liability exposure while enabling payment processors to apply specialized fraud detection and risk management capabilities.

The UCP checkout implementation employs a three-state machine: not_ready_for_payment, ready_for_payment, and completed. This state progression ensures payment readiness validation occurs before transaction authorization, preventing incomplete or malformed checkout attempts. The discrete state transitions provide clear checkpoints for logging, monitoring, and error recovery.

3.3 Implementation Architecture and Performance Considerations

Production implementations demonstrate specific architectural patterns that address performance and reliability requirements. The reference implementation described utilizes the Cerebras model operating at 3,000 tokens per second, enabling real-time conversational interactions without perceptible latency. This inference speed proves critical for maintaining conversational flow, as delays exceeding 200-300 milliseconds create noticeable user experience degradation.

Catalog synchronization between merchant systems and AI platform indices occurs at intervals of several seconds, maintaining inventory parity without imposing excessive computational load. This synchronization frequency balances data freshness against API rate limits and processing overhead. The architecture separates catalog updates from real-time checkout operations, preventing inventory synchronization delays from blocking transaction completion.

Both ACP and UCP implementations utilize identical checkout flow structures despite employing different schema specifications. This functional equivalence suggests potential convergence opportunities, though competitive platform dynamics currently maintain protocol fragmentation.

4. Technical Insights

4.1 Evaluation Framework Requirements

The analysis emphasizes that production deployment without comprehensive evaluation frameworks results in unpredictable agent behavior characterized as "playing whack-a-mole." The Chipotle case study illustrates this vulnerability: users exploited a food ordering agent to obtain free access to AI computational resources by submitting programming questions instead of legitimate orders, bypassing payment requirements entirely. This exploitation demonstrates that agents lacking explicit behavioral constraints will be utilized for unintended purposes.

Four evaluation categories emerge as essential for production reliability. Behavior evaluations prevent off-topic requests by constraining agent responses to domain-appropriate interactions. Protocol compliance evaluations ensure product feeds and API responses conform to specified schemas, preventing malformed data from propagating through the system. Latency benchmarks maintain competitive response times, as conversational AI users expect near-instantaneous feedback. LLM-as-judge quality assessment employs language models to evaluate response quality, appropriateness, and accuracy at scale.

4.2 Security and Privacy Considerations

Sensitive data leakage represents a critical risk in multi-user environments. Without proper isolation constraints, agents may inadvertently reveal information about other customers' shopping activities, including products being considered or checkout status. This vulnerability requires explicit implementation of user-scoped data access controls and query result filtering based on authenticated user identity.

The architectural decision to use payment processors as liability-bearing entities for autonomous payments reflects recognition that merchants lack specialized fraud detection capabilities. Payment processors possess historical transaction data, behavior analysis systems, and risk scoring models that enable more sophisticated fraud prevention than individual merchants can implement independently.

5. Discussion

The current state of Agentic Commerce reveals a domain in transition between human-in-the-loop assistance and autonomous transaction execution. MCP, A2A, and UCP/ACP have achieved production stability with demonstrated adoption across major platforms. However, AP2 adoption remains nascent, with autonomous payment delegation largely theoretical rather than deployed at scale. This gap reflects unresolved challenges in authorization management, liability distribution, and user consent frameworks.

The competitive fragmentation between ACP and UCP protocols introduces interoperability challenges for merchants seeking to support multiple AI platforms. While both protocols provide functionally equivalent capabilities, schema differences require duplicate integration efforts. The potential for convergence or standardization remains uncertain, influenced by competitive platform dynamics and strategic positioning considerations.

The emphasis on evaluation frameworks highlights a maturity gap between conversational AI capabilities and production reliability requirements. The observation that agents without behavioral constraints will be exploited for unintended purposes underscores the necessity of proactive guardrails rather than reactive problem remediation. The recommendation to implement comprehensive evaluation suites before production deployment represents a fundamental architectural principle for agentic systems.

Future development directions include standardization of identity and consent mechanisms across platforms, multi-agent checkout delegation patterns that enable specialized agents to handle specific transaction phases, and convergence of competing protocol standards. The architectural decision space for merchants encompasses both external platform integration (ChatGPT, Gemini) and custom agent development for proprietary websites, suggesting multiple viable implementation strategies depending on organizational capabilities and strategic objectives.

6. Conclusion

This analysis demonstrates that Agentic Commerce represents a fundamental architectural evolution in AI-mediated retail, transitioning from brittle browser automation to standardized API-based protocols. The five-layer protocol stack - comprising MCP, A2A, ACP/UCP, and AP2 - provides the technical infrastructure necessary for production deployments, though autonomous payment delegation remains constrained by authorization and liability challenges.

The practical implications for AI researchers and engineers center on evaluation framework requirements and security considerations. Production systems require comprehensive behavioral evaluations, protocol compliance validation, latency benchmarking, and quality assessment to prevent exploitation and ensure reliable operation. The finding that 45% of agent sessions involve shopping-related queries, combined with market growth projections from $7 billion to $65 billion by 2030, indicates substantial commercial opportunity for organizations that successfully implement robust agentic commerce architectures.

Organizations implementing Agentic Commerce systems should prioritize evaluation framework development alongside protocol integration, recognizing that technical capability without behavioral constraints creates exploitable vulnerabilities. The architectural patterns and protocol specifications examined in this synthesis provide a foundation for building production-grade AI commerce systems that balance user convenience, merchant requirements, and platform reliability.

Sources

About the Author

Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.

LinkedIn | Website | GitHub