A New Era of Agent

The realization of a decentralized agentic ecosystem requires the establishment of standardized communication primitives. Just as the foundational internet relied on TCP/IP and HTTP to connect disparate physical servers, the artificial intelligence landscape is rapidly adopting a newly minted suite of open protocols to orchestrate peer-to-peer collaboration, tool invocation, and human-in-the-loop interactions.

Scalable multi-agent architectures separate decision-making, execution, and governance, naturally mimicking the structure of corporate organizations. But how do these different layers communicate? How does an orchestrator LLM know how to "talk" to a website, verify a tool, or coordinate with another sub-agent?

The answer lies in understanding the complex alphabet soup of modern agent protocols. Let's look at how they fit together and their timeline, specifically focusing on the e-commerce ecosystem.

The Protocol Stack: Timeline and How They Fit Together

The interaction framework of this emerging ecosystem can be conceptualized as a multi-layered protocol stack, specifically designed to handle the asynchronous abstractions of AI communication. This stack did not emerge all at once — it crystallized over roughly fifteen months of rapid iteration:

With this timeline in mind, let's walk through each protocol layer.

1. Tool and Agent Protocols: MCP and A2A

Model Context Protocol (MCP) (Anthropic, 2024) is an open-source standard for connecting AI applications to external systems—data sources, tools, and workflows—via a JSON-RPC client-server interface. Think of MCP like a USB-C port for AI applications: just as USB-C provides a standardized way to connect electronic devices, MCP provides a standardized way to connect AI applications to external systems (Model Context Protocol, 2026).

Before MCP, the industry faced a classic n×m integration problem: every model client (n) had to integrate separately with every tool or service (m)—five AI clients talking to ten internal systems meant fifty bespoke integrations, each with different semantics, authentication flows, and failure modes. Anthropic open-sourced MCP in November 2024, distilling patterns their engineers kept reinventing into a single vendor-neutral protocol. Adoption was immediate: within weeks, contributors from Anthropic, Microsoft, GitHub, OpenAI, and independent developers began expanding and hardening the standard—adding OAuth flows for secure remote servers, refined tool schemas, consistent server discovery patterns, and long-running task support (Woodward, 2025).

By December 2025, Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation, placing it on the same governance path as Kubernetes, GraphQL, and the broader CNCF stack. MCP now supports broad ecosystem adoption across clients like Claude, ChatGPT, VS Code, and Cursor, with a growing registry of community and vendor-maintained servers.

Building on MCP's tool invocation primitives, A2A (Agent-to-Agent) defines a framework for peer-to-peer collaboration using structured messages to manage multi-turn interactions. It relies on "Agent Cards" published at well-known URIs that describe an agent's capabilities, allowing one agent to dynamically discover and delegate tasks to another. Where MCP connects a single agent to tools, A2A connects agents to each other—enabling orchestrators to compose specialized sub-agents into cooperative workflows.

2. UI Protocols: WebMCP, MCP-UI, MCP Apps, AG-UI, and A2UI

While tools run behind the scenes, how do agents interact with the browser and visual interfaces?

The problem with traditional browser agents today is that they operate by extraction and inference. They pull raw HTML, take screenshots, annotate UI elements, and try to guess what a button does—a painfully slow and non-deterministic process. WebMCP (ScaleKit, 2026) is an emerging proposed web standard (spearheaded by an incubation between major browser vendors and AI practitioners like Alex Nahas) that brings MCP natively into the browser. Instead of an agent scraping the DOM to guess what "Add Item" does, your website explicitly declares tools (via declarative HTML attributes on forms, or imperative JavaScript calls with navigator.registerTool). This fundamentally shifts agents from inferring meaning to directly executing typed commands within the user session. You don't need a separate auth layer; WebMCP inherits the browser's SSO and session cookies.

For building isolated full-stack Next.js applications, the Vercel AI SDK (with its Data Stream Protocol) is currently the pragmatic industry standard. It binds server-side tool calls directly to React state and the App Router, allowing the model to naturally emit custom objects and trigger client-side function executions.

However, in wider, decoupled ecosystems, standard UI protocols are gaining traction:

• MCP-UI is a standardized extension to the Model Context Protocol set to launch in 2026, designed to allow servers to provide interactive web components to host applications.
• MCP Apps represent an emerging pattern where AI hosts can render custom UI components directly from backend tools, turning agents into full application surfaces capable of delivering dynamic, context-specific interfaces.
• AG-UI (Agent-Guided UI) is an event-driven protocol that streams a sequence of JSON-encoded events over WebSockets or Server-Sent Events (SSE) for real-time UI synchronization. It offers deep granular controls like tool_call_start lifecycle events and state_snapshot updates.
• A2UI (Agent-to-User Interface) operates as a declarative protocol optimized for LLMs to generate interfaces using structured JSON data (via streams like surfaceUpdate or dataModelUpdate) rather than raw code. While AG-UI excels at real-time telemetry and state synchronization, A2UI excels at generating flexible structural models incrementally by ID.

3. Commerce Protocols: ACP, UCP, and AP2

To enable agents to safely transact in commerce, we require standardized negotiation and payment layers:

• ACP (Agentic Commerce Protocol): OpenAI's open standard (OpenAI, 2025) for embedded commerce inside ChatGPT. Merchants share structured product feeds, implement REST checkout-session endpoints (create → update → complete), and process payments on their own rails via Delegated Payment tokens from a PSP such as Stripe. OpenAI renders the checkout UI; the merchant remains the merchant of record.
• UCP (Universal Commerce Protocol): Uses RESTful calls to advertise merchant capability profiles, manage complex checkout session states (like mapping line items and handling discounts), and deal with post-purchase workflows.
• AP2: Built on W3C Verifiable Credentials standards, this mandates cryptographic signatures on "Mandates." When an agent wants to buy something, it formulates an Intent Mandate, solidifies it into a Cart Mandate, and executes it securely using a Payment Mandate.

4. Discovery, E-Commerce, and Sub-Agents in Practice

The implementation of these protocols is fragmenting along two axes: who aggregates demand and who owns the storefront. The resulting landscape echoes the news aggregation wars of the 2010s — where Google News and Facebook surfaced content but publishers lost control of the customer relationship. In agentic commerce, the question becomes: when a user buys through ChatGPT or Gemini, whose customer are they?

Aggregators: ACP vs UCP

Each major AI assistant is anchoring its commerce strategy around a different protocol. OpenAI's ACP (OpenAI, 2025) powers Instant Checkout inside ChatGPT — now approaching ~800 million weekly active users (Pilarczyk, 2025) — centralizing the entire purchase experience within its own UI while merchants remain the merchant of record. Google's UCP, backed heavily by Shopify, takes the opposite bet: a distributed model where merchant capability profiles are advertised openly and any agent can orchestrate multi-step checkout flows.

The split mirrors a familiar platform dynamic. ACP keeps the customer inside ChatGPT's walled garden, much as Google News once kept readers on Google; UCP distributes the transaction layer, much as RSS once distributed content. For merchants, the practical consequence is a two-front integration burden — supporting both protocols is quickly becoming table stakes for visibility, just as optimizing for Google Shopping and Amazon Marketplace was a decade ago.

Storefronts and Discovery: Three Adoption Postures

On the storefront side, protocol adoption is stratifying into three clear postures:

Full-stack adopters are committing to multiple protocol layers simultaneously, betting that agent-mediated traffic is inevitable and that structured discoverability is the new SEO. Algolia leads discovery by publishing two MCP offerings (Algolia, 2026): a Public MCP that exposes curated indices and Recommend models to external agents (ChatGPT, Claude, Vertex AI, Perplexity, etc.) for production search and product discovery, and a Productivity MCP for internal, user-scoped analytics and automation. Shopify has aggressively done the same, defaulting to MCP across its platform while heavily backing the UCP on the commerce side. Saleor has been one of the fastest movers in the headless space — shipping an MCP server (Gębala, 2025) in November 2025, launching an ACP-powered Instant Checkout app for ChatGPT (Pilarczyk, 2025b) weeks later, and by February 2026 positioning as "the first fully open, end-to-end AI-native commerce stack" (Mencel, 2026) with UCP and AP2 planned next. Their velocity — zero protocol support to full MCP + ACP + conversational AI ("Ink AI") in under four months — illustrates how quickly the ecosystem is hardening.

Selective integrators adopt MCP for developer productivity or basic agent exposure, but protect their proprietary core. Commercetools abstracted these layers into an "AI Hub and Agent Gateway", including a Developer MCP for scaffolding, but keeps its core commerce engine proprietary. Bloomreach offers a basic MCP integration (Loomi Connect) for ChatGPT but avoids UCP and A2A integration, fiercely protecting their proprietary algorithm and merchandising environments.

Non-adopters remain purely REST/GraphQL dependent. Recombee, for instance, ignores emerging agent standards entirely — a growing risk as comparative buying agents gain traction and preferentially route traffic to merchants that expose structured, protocol-compliant endpoints. The companies adopting fastest aren't simply checking compliance boxes; they are positioning themselves as the backends that every agent can transact through. For non-adopters, the bet is that their algorithm moat is worth more than interoperability — a wager that grows riskier as protocol adoption approaches table stakes.

Assembling the Stack: Three Routes, One Question

Section 4 posed the question: when a user buys through ChatGPT or Gemini, whose customer are they? The answer depends on which route the transaction takes through the protocol stack — and each route shifts the balance of power between aggregator, agent, and merchant.

Three routes converge on the e-commerce platform. They are ordered below from least merchant control to most — a gradient that determines who captures the customer relationship.

Route 1: AI Aggregators (ACP / UCP → Merchant APIs) — Merchant as Supplier

When a user asks ChatGPT to "find me a moisturizer for sensitive skin under €40", the aggregator does not call the merchant's MCP tools. ACP and UCP are self-contained commerce protocols focused on cart, checkout, and payments — MCP plays no role here. Under ACP, merchants pre-push structured product feeds to OpenAI, which indexes them internally; when a user query matches, OpenAI surfaces relevant products from its own index, then orchestrates checkout via ACP-specific REST endpoints (create → update → complete) that hit the merchant's checkout API directly. Under UCP, Google relies on its existing Merchant Centre infrastructure for product discovery, with UCP handling the checkout session state, line items, discounts, and post-purchase flows. In neither case does the aggregator route through the merchant's MCP API or Storefront Agent — the storefront UI is never rendered, and the transaction is entirely API-to-API.

This is the route where merchants cede the most control. The aggregator owns the UI, the conversation context, and the ranking of which merchants surface first. The merchant becomes a supplier to someone else's storefront. Unlike SEO-era Google, where keyword-stuffed metadata could game rankings, LLM-powered aggregators use vector retrieval models that are largely insensitive to feed formatting tricks. The only levers that matter are unique supply — exclusive brands, complete size runs, variants competitors lack — and price. A merchant with the same commodity catalogue as ten others will be selected on cost alone; a merchant with differentiated inventory owns a structural advantage no amount of feed optimization can replicate.

Route 2: Foreign Agents (A2A → Storefront Agent → MCP) — Merchant as Negotiating Peer

Unlike aggregators, independent agents — comparative shopping bots, personal buying assistants, enterprise procurement systems — don't operate within a walled-garden UI. They reach merchants in one of three ways: calling MCP tools directly, delegating via A2A, or scraping. When such an agent receives a mandate like "procure a highly-rated ergonomic office chair under $300 with fast shipping", the scraping path is brittle and slow; the MCP path forces the agent to navigate unfamiliar schemas and decompose the mandate into individual tool calls — search, filter, check stock, calculate shipping — across a backend it doesn't understand. A2A delegation is the structured alternative: the agent passes the entire high-level intent to the merchant's Storefront Agent as a single structured message.

The Storefront Agent receives that intent, decomposes it internally, queries the unified search and recommendation infrastructure via MCP, applies business rules (margin constraints, personalization, stock prioritization), and hands back a resolved cart. The merchant retains full control over ranking, pricing strategy, and the transaction — a fundamentally different power dynamic from the aggregator route, where the merchant never touches the conversation.

Route 3: Direct Visitors (Chat / UI → Storefront Agent → AG-UI) — Merchant as Host

For human shoppers arriving directly — still the majority of e-commerce traffic — the Storefront Agent operates as an on-site co-pilot. The Chat interface feeds user queries to the agent, which uses MCP internally to execute tool calls against the same search, recommendation, and inventory infrastructure. But here, instead of handing results back to a foreign caller, the agent manipulates the Storefront UI in real-time via AG-UI, streaming state updates that replace legacy faceted navigation with reactive, intent-driven layouts.

This is the route where the merchant owns the customer most completely — and the one that rewards the deepest investment. The storefront controls the brand experience, the conversation history, and the first-party data loop: every query, click, and purchase feeds back into personalization models that make subsequent interactions more relevant. A user asking "show me something like this but warmer" requires multimodal retrieval, semantic understanding, and real-time inventory awareness — capabilities that only exist if the discovery infrastructure beneath the agent is genuinely world-class. Unlike Routes 1 and 2, there is no intermediary to blame for poor results. The Storefront Agent's value to the visitor is entirely contingent on the quality of the discovery layer it invokes.

The Gradient and the Multiplier

The three routes form a clear gradient of merchant control: supplier → peer → host. But the gradient is also a migration path: when discovery fails in Routes 2 and 3, users migrate toward Route 1 — surrendering the customer relationship to aggregators by default. In Route 2, discovery quality determines whether the Storefront Agent can decompose a foreign mandate into a competitive offer. In Route 3, it determines whether conversational search converts or frustrates. Get either wrong, and shoppers learn it's faster to ask ChatGPT — shifting traffic to Route 1, where the merchant is just a supplier to someone else's UI.

This is why protocol adoption alone is insufficient. A merchant can implement every layer of the stack — MCP, A2A, ACP, AG-UI — and still underperform if the underlying search and recommendation engine returns poor results. Conversely, best-in-class discovery infrastructure acts as a multiplier across the routes the merchant actually controls: sharper A2A delegation means more mandates won, and higher-quality on-site search means direct visitors stay, convert, and return — keeping traffic in Routes 2 and 3, where the merchant owns the relationship.

The fifteen-month sprint from MCP's open-source debut to a full protocol stack governing tools, UIs, commerce, and agent delegation suggests we are still in the earliest phase of this architectural shift. But the structural logic is already legible. The merchants that assemble the complete stack will participate in the agentic economy. The ones that assemble it around best-in-class discovery will own the customer within it.