The Intermediation Problem

For two decades, the B2B2C model has been the dominant architecture of digital commerce. A brand manufactures a product. A platform - Shopify, Amazon, a marketplace, a retailer - intermediates the relationship with the consumer. The consumer discovers, evaluates, and purchases through the platform's interface. Each party has a defined role, a known set of touchpoints, and a relatively stable allocation of value.

That architecture is now being restructured from within. At Shoptalk 2026, Shopify activated Agentic Storefronts by default for all merchants, enabling products to be discovered and purchased directly within ChatGPT, Microsoft Copilot, and Google AI Mode. Google expanded its Universal Commerce Protocol to support multi-item carts, loyalty linking, and real-time catalogue access. Amazon's "Buy for Me" agent now shops other brands' websites on behalf of consumers, processing every transaction through Amazon's own checkout. Salesforce rebranded its entire commerce platform as "Agentforce Commerce."

What these announcements share is not merely the introduction of AI. It is the introduction of agents at every layer of the B2B2C chain. The brand deploys a seller agent. The platform deploys an orchestration agent. The consumer's AI assistant acts as a buyer agent. The result is not B2B2C commerce with AI assistance. It is agent-to-agent-to-agent commerce - a fundamentally different architecture with fundamentally different design requirements.

This essay examines what happens when the B2B2C value chain becomes agentic. It analyses how trust propagates across multi-party agent chains, how delegation cascades through multiple boundaries, how platforms accumulate structural power in agent-mediated markets, and what Agentic Experience Design must address to make these chains governable, observable, and trustworthy.

The B2B2C model predates digital commerce. A manufacturer sells to a retailer, who sells to a consumer. The retailer adds value through curation, merchandising, logistics, and customer service. The consumer benefits from aggregated selection, trusted returns policies, and the convenience of a single shopping destination. The brand benefits from distribution reach it could not achieve alone.

Digital platforms extended this model without fundamentally changing it. Shopify enabled any brand to reach consumers through a platform-hosted storefront. Amazon Marketplace allowed third-party sellers to access Amazon's customer base. Salesforce Commerce Cloud gave enterprises the infrastructure to sell through channel partners. In each case, the platform intermediated the relationship between brand and consumer, and the consumer navigated a human-designed interface to make purchasing decisions.

The critical assumption of this model is that the consumer is present. Present to see the brand's packaging. Present to read reviews. Present to compare prices. Present to feel the friction of checkout and decide whether the purchase is worth completing. Every element of traditional B2B2C design - from product detail pages to loyalty programmes to abandoned cart emails - assumes a human being on the other side of the screen.

That assumption is dissolving. Gartner predicts that by 2028, AI agents will handle 90 per cent of all B2B purchases, representing over $15 trillion in annual spend. Bain and Company reports that 30 to 45 per cent of US consumers already use generative AI to research and compare products. The consumer is not disappearing from the chain. But the consumer is increasingly delegating to an agent that acts on their behalf - an agent that does not see packaging, does not read reviews the way humans do, and does not feel checkout friction.

When the B2B2C chain becomes agentic, three distinct agent layers emerge. Each layer has its own objectives, its own constraints, and its own principal - the entity on whose behalf the agent acts. Understanding these layers is essential to designing the trust, delegation, and observability structures that govern the chain.

The Brand Agent operates on behalf of the manufacturer or brand. Its function is to expose product data, pricing, inventory, and fulfilment capabilities to platform and consumer agents. In the Shopify Agentic Storefronts model, the brand agent is the merchant's product catalogue made machine-readable through structured data feeds. In more sophisticated implementations, the brand agent negotiates terms, applies promotional logic, and manages real-time inventory allocation across channels. The brand agent's principal is the brand itself, and its objective is to maximise qualified transactions while maintaining brand integrity and margin.

The Platform Agent operates on behalf of the intermediary - Shopify, Amazon, Google, or any marketplace that connects brands to consumers. Its function is to orchestrate discovery, facilitate checkout, and manage the trust infrastructure that makes transactions possible. Google's Universal Commerce Protocol positions the platform agent as the orchestration layer that routes consumer agent queries to brand agents, manages identity linking, and processes payments. Amazon's "Buy for Me" agent is a platform agent that actively shops other brands' websites on the consumer's behalf, routing all transactions through Amazon's payment and fulfilment infrastructure. The platform agent's principal is the platform, and its objective is to maximise platform value - which may or may not align with the brand's or the consumer's interests.

The Consumer Agent operates on behalf of the end buyer. Its function is to interpret the consumer's intent, discover products across multiple platforms and brands, compare options, and execute purchases within delegated authority. ChatGPT's shopping capabilities, Google's AI Mode, and Microsoft Copilot all function as consumer agents. The consumer agent's principal is the consumer, and its objective is to fulfil the consumer's delegated intent - finding the best product at the best price with the best terms, as defined by the consumer's preferences and constraints.

The design challenge is that these three agents have three different principals with three different objectives. The brand agent wants to sell its products at margin. The platform agent wants to maximise platform engagement and transaction volume. The consumer agent wants to find the optimal outcome for its principal. In traditional B2B2C, these tensions were mediated by the consumer's own judgement - the human who could weigh brand loyalty against price, convenience against ethics, platform trust against direct-to-consumer alternatives. In agentic B2B2C, these tensions must be mediated by protocol, policy, and design.

In direct-to-consumer agentic commerce, trust architecture operates across a single boundary: the consumer trusts their agent, and the agent interacts with the brand. In B2B2C agentic commerce, trust must propagate across at least two boundaries, and often more. The consumer trusts their agent. The consumer's agent must trust the platform agent. The platform agent must trust the brand agent. And each of these trust relationships has different characteristics, different failure modes, and different recovery requirements.

Consider a concrete scenario. A consumer asks their AI assistant to purchase a specific running shoe. The consumer agent queries Google's Universal Commerce Protocol, which returns product data from multiple brand agents through Shopify's Agentic Storefronts. The consumer agent selects a product, initiates checkout through the platform's payment infrastructure, and completes the transaction using a Stripe Shared Payment Token. At every boundary in this chain, trust must be established, verified, and maintained.

The consumer trusts their agent to interpret their intent correctly - to understand that "the best running shoe" means something specific given their running history, foot shape, and budget. The consumer's agent trusts the platform to return accurate, current product data - not stale inventory or manipulated pricing. The platform trusts the brand agent to honour the terms it exposes - to actually have the product in stock, to ship within the stated timeframe, and to accept returns as advertised. The brand trusts the platform to represent its products faithfully and to route legitimate consumer agents rather than fraudulent ones.

Each of these trust relationships can fail independently. The consumer agent might misinterpret intent. The platform might serve biased results that favour its own margin. The brand agent might expose inaccurate inventory. The payment token might be used beyond its delegated authority. In traditional B2B2C, the consumer could detect many of these failures through direct observation - seeing the wrong product in their cart, noticing a suspicious price, reading a review that contradicts the product description. In agentic B2B2C, the consumer is absent during the transaction. Trust failures may not be detected until after the purchase is complete and the product arrives.

This is why trust architecture in B2B2C agentic commerce cannot be designed as a single layer. It must be designed as a propagation system - a chain of verifiable trust relationships where each boundary has its own verification mechanisms, its own failure detection, and its own recovery protocols. The AXD Institute's Trust Calibration Model provides the theoretical foundation, but B2B2C chains require extending it to multi-party contexts where trust is not binary but graduated, not static but dynamic, and not local but propagated.

The most structurally significant consequence of B2B2C agentic commerce is the concentration of power at the platform layer. In traditional B2B2C, the platform intermediary added value through curation, logistics, and customer trust. In agentic B2B2C, the platform controls something far more consequential: the orchestration layer that determines which brand agents are discoverable, what data flows to consumer agents, and how transactions are processed.

Bain and Company's research on agentic commerce identifies three strategic positions for retailers in the agentic era: embrace the agents, build the agents, or fortify the home site. But these positions are not equally available to all participants. Amazon has already staked out the most aggressive position - its "Buy for Me" agent shops other brands' websites but processes all transactions through Amazon, giving Amazon access to customer data and transaction economics even when the product comes from a competitor. Amazon has simultaneously prohibited external agents from interacting with its own site directly, creating an asymmetric architecture where Amazon's agent can access everyone else, but no one else's agent can access Amazon.

Shopify's approach is different in structure but similar in effect. By activating Agentic Storefronts by default for all merchants, Shopify positions itself as the infrastructure layer through which brand agents become visible to consumer agents. Merchants gain distribution through ChatGPT, Copilot, and Google AI Mode, but the checkout, payment, and fulfilment infrastructure remains Shopify's. The merchant's brand identity is mediated through Shopify's structured data layer, and the consumer's experience of the brand is shaped by how Shopify's agent represents it to the consumer's agent.

Google's Universal Commerce Protocol represents a third model - an open protocol that any platform or brand can implement. But even open protocols create power dynamics. Google controls the consumer-facing AI interfaces (Gemini, AI Mode, Google Search) through which most consumer agents will operate. A brand that implements UCP gains discoverability, but that discoverability is mediated by Google's ranking, filtering, and presentation logic. The protocol is open. The distribution is not.

Bain's consumer research reveals why this matters: shoppers trust retailers' on-site agents three times more than third-party agents. This trust asymmetry gives platforms with direct consumer relationships - Amazon, Google, Apple - a structural advantage that compounds as agent-mediated commerce scales. The platform that controls the consumer's agent controls the chain.

B2B2C agentic commerce requires a protocol stack that enables agents at each layer to communicate, transact, and settle payments without human intervention at each boundary. As documented in the AXD Institute's Protocol Tracker, three protocols are converging to form this stack, each addressing a different layer of the chain.

Discovery and Catalogue Layer: Google's Universal Commerce Protocol (UCP). UCP provides the machine-readable interface through which consumer agents query brand agents for product data, pricing, inventory, and fulfilment options. At Shoptalk 2026, Google expanded UCP to support multi-item carts, loyalty programme linking through Identity Linking, and streamlined merchant onboarding through Google Merchant Center. For B2B2C chains, UCP functions as the language through which platform agents aggregate brand catalogues and expose them to consumer agents. The protocol is open-source and vendor-agnostic, but its primary distribution channel is Google's own AI interfaces.

Transaction Layer: OpenAI's Agentic Commerce Protocol (ACP). ACP provides the transaction infrastructure for agent-to-agent purchasing. After abandoning its initial "Instant Checkout" approach, OpenAI pivoted to a discovery-first architecture that delivers real-time product data from major retailers including Target, Sephora, Nordstrom, Home Depot, Best Buy, and Wayfair. For B2B2C chains, ACP enables the consumer agent to initiate and complete purchases through platform agents without redirecting to human-facing checkout flows.

Payment Layer: Stripe's Machine Payments Protocol (MPP). MPP provides the payment infrastructure purpose-built for machine-to-machine transactions. Its central innovation is the Shared Payment Token - a delegated spending credential that allows a consumer to grant their agent limited, revocable payment authority. For B2B2C chains, MPP addresses the critical question of how payment authority propagates from consumer to consumer agent to platform agent to brand agent without requiring human approval at each boundary. Mastercard's live agentic payment transactions in Latin America, using tokenised credentials and biometric verification, demonstrate that the payment layer is already moving from protocol to production.

The convergence of these protocols creates the technical infrastructure for B2B2C agent commerce. But protocols alone do not solve the design problem. They enable communication between agents. They do not govern the relationships between the humans those agents represent.

Delegation design in direct-to-consumer agentic commerce involves a single transfer of authority: the consumer delegates to their agent. In B2B2C agentic commerce, delegation cascades through multiple boundaries, and each cascade introduces new questions about authority, constraint, and revocation.

The consumer delegates purchasing authority to their agent - "buy me running shoes under 150 pounds with next-day delivery." The consumer's agent must then delegate a subset of that authority to the platform agent - querying catalogues, comparing options, initiating checkout. The platform agent may further delegate to a brand agent - requesting real-time inventory, negotiating promotional terms, arranging fulfilment. At each boundary, the original delegation must be preserved, constrained, and verifiable.

The design challenge is that delegation does not propagate cleanly across boundaries. The consumer's constraint of "under 150 pounds" is clear to the consumer's agent. But when the platform agent queries brand agents, it must translate that constraint into the brand's pricing structure - which may include dynamic pricing, bundle discounts, loyalty member pricing, or promotional codes that the consumer's agent does not know about. The platform agent must decide whether to apply a loyalty discount that reduces the price below the consumer's threshold but requires sharing the consumer's identity with the brand. That decision involves a delegation boundary that the consumer may not have explicitly addressed.

Stripe's Shared Payment Tokens provide a partial solution for the payment dimension of delegation cascades. A consumer can grant their agent a token with specific spending limits, merchant categories, and expiration conditions. But payment authority is only one dimension of delegation. The consumer may also need to delegate identity sharing authority (can the agent share my loyalty number?), data sharing authority (can the agent share my purchase history for better recommendations?), and commitment authority (can the agent agree to a subscription or recurring purchase?). Each of these delegation dimensions must cascade through the B2B2C chain with appropriate constraints at each boundary.

The AXD Institute's Delegation Design framework addresses single-boundary delegation. B2B2C agentic commerce requires extending this framework to multi-boundary cascades where authority attenuates, transforms, and must be recoverable at each layer.

When a transaction fails in traditional B2B2C commerce, liability follows a relatively clear path. If the product is defective, the brand is liable. If the delivery fails, the logistics provider is liable. If the payment is fraudulent, the payment processor and the merchant share liability according to established card network rules. Consumer protection law, contract law, and decades of case law provide the framework for allocating responsibility.

In B2B2C agentic commerce, the liability chain becomes far more complex. Consider a scenario where a consumer's agent purchases a product through a platform agent that sourced it from a brand agent, and the product does not match the consumer's intent. The consumer asked for "hypoallergenic moisturiser suitable for sensitive skin." The consumer's agent interpreted this as a set of ingredient constraints. The platform agent matched those constraints against brand agent data. The brand agent returned a product that met the stated constraints but contained a fragrance compound that the consumer is allergic to - a compound not listed in the structured data the brand agent exposed.

Who is liable? The brand, for incomplete product data? The platform, for not requiring more comprehensive ingredient disclosure? The consumer's agent, for not asking about specific allergens? The consumer, for not specifying their allergy in the delegation? As the AXD Institute's essay on Liability and the Agent argues, existing legal frameworks were not designed for multi-agent chains where decisions are distributed across autonomous systems operating on behalf of different principals.

The design implication is that liability must be architecturally addressable - not just legally resolvable after the fact. Each boundary in the B2B2C chain must have explicit contracts (in the technical sense) that specify what data each agent is responsible for providing, what decisions each agent is authorised to make, and what happens when the chain produces an outcome that no single agent intended. This is not a legal problem that designers can defer to lawyers. It is a design problem that determines whether B2B2C agentic commerce can operate at scale without destroying consumer trust.

The most provocative question in B2B2C agentic commerce is whether the "2B" in the middle survives. If a consumer's agent can query brand agents directly through open protocols like UCP, negotiate terms through ACP, and settle payments through MPP - why does the platform intermediary exist at all?

The Agile Brand Guide has formalised this question through its B2A2C (Business to Agent to Consumer) model, which describes commerce where the agent replaces the platform as the primary intermediary. In this model, the consumer's agent becomes the marketplace - aggregating products from multiple brand agents, comparing options, and executing transactions without routing through a traditional platform. The platform's historical value propositions - curation, trust, logistics aggregation - are absorbed by the agent layer.

There are strong arguments for this thesis. Open protocols reduce the technical barriers to direct brand-to-consumer-agent communication. Machine customers do not need the visual merchandising, editorial curation, or social proof that platforms provide to human shoppers. Agent-to-agent transactions can be settled through payment protocols without platform-mediated checkout. If the agent can do everything the platform does, the platform becomes a cost centre rather than a value creator.

But there are equally strong arguments against it. Platforms provide trust infrastructure that agents cannot easily replicate - buyer guarantees, dispute resolution, verified seller programmes, and the accumulated reputation that comes from millions of successful transactions. Bain's research shows that consumers trust platform agents three times more than third-party agents. Platforms also provide logistics infrastructure - warehousing, shipping, returns processing - that cannot be abstracted into a protocol. And platforms have regulatory relationships - tax collection, consumer protection compliance, cross-border trade facilitation - that individual brand agents cannot replicate.

The more likely outcome is not disintermediation but re-intermediation. The platform's role changes from interface provider to trust infrastructure provider. The platform no longer needs to design the shopping experience - the consumer's agent handles that. But the platform still needs to verify brand agents, guarantee transactions, manage disputes, and provide the trust layer that makes agent-to-agent commerce possible at scale. The design question is not whether platforms survive. It is what platforms become when their primary customers are agents rather than humans.

B2B2C agentic commerce introduces five design challenges that extend the current scope of Agentic Experience Design. Each challenge requires new frameworks, new methods, and new design questions that go beyond single-boundary agent design.

Multi-party trust propagation. Trust in B2B2C agent chains is not a property of any single relationship. It is a propagated property that must flow across brand, platform, and consumer agent boundaries. The AXD Institute's trust architecture frameworks must be extended to model trust as a chain property - where the weakest link determines the chain's trustworthiness, and where trust failures at one boundary can cascade to others. Designers must specify how trust is established at each boundary, how trust signals propagate across boundaries, and how trust failures are detected and contained before they cascade.

Delegation cascade design. Single-boundary delegation - consumer to agent - is well understood within AXD. Multi-boundary delegation - consumer to consumer agent to platform agent to brand agent - requires new design patterns for authority attenuation, constraint translation, and cascade revocation. When a consumer revokes their agent's authority, that revocation must propagate through every downstream agent in the chain. When a constraint changes mid-transaction, every agent in the chain must be notified and must adjust.

Liability chain architecture. Designers must specify, at each boundary in the B2B2C chain, what data each agent is responsible for, what decisions each agent is authorised to make, and what happens when distributed decisions produce unintended outcomes. This is not post-hoc legal allocation. It is pre-hoc architectural design that determines whether the chain can operate without destroying consumer trust.

Brand representation through intermediation. When a consumer's agent purchases a brand's product through a platform agent, the consumer may never see the brand's name, packaging, or messaging. The brand's identity is reduced to structured data fields in a protocol response. Designers must create new approaches to brand representation that work in agent-mediated contexts - where brand value must be encoded in data quality, fulfilment reliability, and post-purchase experience rather than visual identity and marketing narrative.

Cross-chain observability. The AXD Institute's work on agent observability addresses visibility into single-agent behaviour. B2B2C chains require cross-chain observability - the ability to trace a transaction from consumer intent through consumer agent, platform agent, and brand agent, identifying where decisions were made, what data informed them, and where failures occurred. Without cross-chain observability, neither the consumer nor any party in the chain can understand what happened when something goes wrong.

The B2B2C model is not disappearing. It is becoming agentic. And the transition from human-mediated to agent-mediated value chains is not a technology upgrade. It is an architectural transformation that changes who controls the customer relationship, how trust propagates across parties, how delegation cascades through boundaries, and how liability is allocated when distributed systems produce unintended outcomes.

The companies that announced B2B2C agentic commerce infrastructure at Shoptalk 2026 - Shopify, Google, Amazon, Salesforce, Stripe, Mastercard - are not building features. They are building the structural architecture of agent-mediated markets. The protocols they are deploying (UCP, ACP, MPP) enable the technical communication between agents. But protocols do not design trust. Protocols do not allocate liability. Protocols do not ensure that a consumer's intent is faithfully represented through three layers of agent intermediation.

That is the work of Agentic Experience Design. And B2B2C agentic commerce makes that work harder, because the designer is no longer designing a single agent's behaviour. The designer is designing the chain - the multi-party system of agents, protocols, trust relationships, delegation cascades, and liability allocations that determines whether agent-mediated commerce serves the humans it claims to represent.

The intermediation problem is, at its core, a design problem. And it is the most consequential design problem in agentic commerce today.