Agentic Commerce: How AI Agents Are Transforming B2B Product Discovery
The B2B buying experience is undergoing a more fundamental shift than anything the industry has seen since the move from print catalogues to ecommerce websites. For two decades, the dominant model has been search-and-browse: a human buyer types a query, scans results, filters by attribute, and adds items to a basket. The interface is better than a paper catalogue, but the underlying paradigm is the same. The human is doing the work.
Agentic commerce changes this at its root. Instead of a buyer navigating your storefront, an AI agent does it on their behalf — understanding complex B2B requirements, querying your catalogue in ways no keyword search supports, and completing procurement tasks autonomously or with minimal human oversight. The buyer’s interface is a conversation, or increasingly, no interface at all. The buying system handles it.
This is not a distant prospect. Agentic commerce is emerging in B2B contexts right now, driven by the convergence of mature large language models, standardised agent-to-tool communication protocols, and composable commerce architectures that were — perhaps unknowingly — built for exactly this moment.
What Agentic Commerce Actually Means in B2B
The term “agentic commerce” encompasses a spectrum of AI-driven buying behaviours, from AI-assisted procurement to fully autonomous purchasing agents.
At the assisted end, a procurement manager instructs an AI assistant: “Find me three suppliers for M12 stainless steel hex bolts with a minimum tensile strength of 800 MPa, check our contract pricing, and add the preferred option to my order queue.” The agent queries the relevant commerce APIs, evaluates the results against the stated requirements, and returns a structured recommendation. The human approves.
At the autonomous end — increasingly realistic for repeat procurement and low-risk categories — an AI agent monitors inventory levels, detects reorder triggers, identifies the correct SKU from a catalogue of tens of thousands, validates pricing against the active contract, and submits the purchase order, all without human initiation.
In both cases, the critical point is this: the agent is your customer. Not the human. The agent is the one interacting with your catalogue, your pricing API, and your checkout flow. If your commerce architecture is not designed with agent-readable data structures, machine-consumable APIs, and structured product information, you are invisible to an increasingly large share of B2B procurement activity.
With 92% of US brands having implemented some form of composable commerce, the API-first infrastructure is already in place at most enterprise retailers. The question is whether that infrastructure is ready to serve AI agents as first-class customers — not just humans using browsers.
The B2B Procurement Requirements That Make Agents Essential
B2B procurement is structurally more complex than B2C in ways that make it particularly suited to AI agent mediation. Consider what a procurement professional must navigate for a single purchase:
Contract pricing compliance. The buying organisation has negotiated specific rates with specific suppliers. Purchasing outside contracted terms has financial and compliance consequences. An AI agent can enforce this consistently across every transaction, checking that the selected product and price match the active contract before proceeding.
Specification matching. Industrial and technical B2B purchasing requires matching products to precise technical specifications — material grades, tolerance ranges, compliance certifications (CE, REACH, RoHS), and compatibility with existing installed equipment. Natural language product discovery B2B use cases are particularly compelling here: an agent can interpret “replace the existing filtration unit rated for 150 bar at 80°C in our hydraulic system” and find the correct replacement part from a catalogue of thousands of components, a task that would defeat a conventional search engine and consume significant time from a human buyer.
Approval workflow navigation. B2B purchases above certain thresholds require authorisation from budget holders. An AI agent that understands the buying organisation’s approval rules can structure orders to route correctly, flag when thresholds will be exceeded, or split orders where that is permitted and beneficial.
Supplier diversification and risk management. Sophisticated procurement teams evaluate not just price and specification but supplier lead times, stock availability, and supply chain risk. An AI agent with access to the right data can factor all of these into its recommendations automatically.
These requirements make B2B procurement substantially more demanding than a simple keyword search and add-to-cart flow. They are also requirements that AI agents, properly connected to commerce and enterprise systems, are well-positioned to meet.
How Composable Architecture Enables Agent Integration
The composable commerce architecture that many B2B organisations have adopted over the past several years — API-first, MACH-aligned, with clean separations between catalogue, pricing, cart, and checkout — turns out to be exceptionally well-suited to AI agent integration.
This is not coincidental. The same qualities that make composable commerce valuable to human developers — predictable APIs, granular endpoints, structured data contracts, and separation of concerns — make it accessible to AI agents. An agent that can call GET /v2/products?filter=material:stainless-steel&tensile_strength_min=800 and receive structured JSON it can reason over is an agent that can serve your buyers effectively.
Monolithic commerce platforms, by contrast, typically optimise for human browser interfaces: rendered HTML pages, JavaScript-heavy storefronts, session-based state. These interfaces are opaque to AI agents. The agent cannot extract structured product data from a rendered HTML page with anything like the reliability and precision that a clean API provides.
The API Design Considerations for Agent-Mediated Commerce
If AI agents will be primary customers of your commerce APIs, certain design considerations become significantly more important:
Structured product attributes over narrative description. An agent that needs to find products meeting a specification can query filter=operating_temperature_max_celsius:80 with certainty. It cannot reliably extract “suitable for use up to 80°C” from an unstructured product description. Technical attribute data must be structured, typed, and consistently populated across the catalogue.
Semantic richness in API responses. Beyond raw attributes, product data should include the context an agent needs to reason about suitability: compatibility information, required accessories, regulatory status, and relationship data (which products are variants, superseded by, or frequently ordered alongside this item).
Unambiguous pricing endpoints. For contract pricing to work in an agentic context, the pricing API must return the specific contracted price for a given buyer identity, quantity, and product combination in a single, unambiguous call. Pricing that requires session state, promotional codes applied through UI interaction, or manual negotiation cannot be consumed by an agent.
Stable, well-documented API contracts. Agents are built against API contracts. Frequent breaking changes, inconsistent response structures, or undocumented fields create brittleness in agent implementations. Commerce APIs designed for agentic consumption need the same stability and documentation rigour as public developer APIs.
Idempotent operations with clear transaction semantics. An agent adding items to a cart or submitting an order must be able to do so reliably. APIs that require specific UI state, use CSRF tokens designed for browser sessions, or have unclear behaviour on retry present integration challenges that composable, REST-first APIs avoid by design.
Elastic Path’s Composable Commerce MCP Server
A concrete example of how the commerce ecosystem is adapting to the agentic paradigm is Elastic Path’s Composable Commerce MCP Server. The Model Context Protocol (MCP) is an open standard for connecting AI agents to external tools and data sources, providing a standardised interface that AI platforms — including Anthropic’s Claude, OpenAI’s ChatGPT, and emerging enterprise AI systems — can use to interact with external services.
Elastic Path’s MCP Server exposes commerce operations as MCP-compatible tools, enabling AI agents to perform operations including product catalogue search, product detail retrieval, cart management, order submission, and pricing lookup through a standardised protocol. An AI assistant integrated with the Elastic Path MCP Server can execute queries like “find products matching this specification and check our contract pricing” by calling structured MCP tools rather than attempting to parse or interact with a web interface.
This matters for several reasons:
Ecosystem compatibility. Because MCP is an open standard, an Elastic Path MCP Server works with any MCP-compatible AI platform. Organisations are not locked into a single AI vendor. The commerce capability is decoupled from the AI capability.
Operational coverage beyond purchasing. MCP servers can expose operational capabilities — order status enquiries, inventory checks, catalogue updates — alongside transactional capabilities. An internal procurement AI agent can check order status, query available stock, and confirm pricing without a human logging into a commerce admin interface.
Developer accessibility. Building an AI agent that connects to Elastic Path via MCP is significantly faster than building a bespoke integration using raw REST APIs. The MCP protocol handles discovery, authentication, and parameter passing in a standardised way.
For commerce architects evaluating how to make their Elastic Path implementation agent-ready, the MCP Server represents a meaningful step: it provides a defined, maintainable integration point rather than expecting AI agents to reverse-engineer the existing API surface.
Elastic Path Semantic Search AI: Vector-Based Product Discovery
Alongside the MCP Server, Elastic Path has expanded its product discovery capabilities with native semantic search powered by vector embeddings. This is directly relevant to AI agents ecommerce product discovery use cases and changes the economics of agent-mediated catalogue interaction.
From Keyword to Vector Search
Traditional keyword search matches query terms against product attribute values. The search engine looks for the words “hydraulic filter” in product names and descriptions. If the product is described as a “high-pressure fluid management component for hydraulic circuits,” the keyword search fails to surface it in response to a “hydraulic filter” query.
Semantic search using vector embeddings works differently. Both the query and each product are encoded as high-dimensional vectors that capture semantic meaning. Products and queries with similar meaning — regardless of whether they share specific words — have similar vector representations. Similarity search finds the closest product vectors to the query vector, surfacing semantically relevant results even when the terminology differs.
For AI-powered ecommerce search natural language use cases, this is transformative. An agent can issue a natural language query — “hydraulic filtration component rated for 150 bar continuous operation with stainless internal components” — and semantic search surfaces the most relevant products based on meaning, not keyword matching.
Implications for Catalogue Data Strategy
The shift to semantic search has implications for how catalogues should be structured and enriched. Vector embeddings are generated from product data, so the quality and completeness of that data directly affects search relevance.
Products with rich, accurate, attribute-complete data generate better embeddings and appear more reliably in relevant searches. Products with sparse descriptions, missing technical attributes, or generic category names become harder to discover through both semantic search and agent-mediated queries.
This creates a new imperative for catalogue management: product data quality is no longer just about making products legible to human browsers. It is about making them discoverable by AI systems. The product data strategy that serves a human browsing a filtered category page is not sufficient for serving an AI agent performing specification-driven discovery.
Concretely, this means:
- Technical specifications must be captured as structured, typed attributes — not embedded in unstructured text.
- Product descriptions should use consistent, industry-standard terminology rather than marketing language that varies by copywriter.
- Relationship data (accessories, replacements, compatible equipment) must be maintained as structured associations, not narrative text.
- Missing attributes are not just gaps in human-facing UX — they are gaps in the vector embeddings that determine discoverability.
The Implications of Agent-First Commerce Architecture
Embracing agentic commerce as a strategic direction requires rethinking some assumptions that have shaped B2B commerce design for two decades.
The Storefront Is Not the Primary Interface
Commerce teams have invested substantially in storefront experience: UX design, search UI, navigation taxonomies, promotional merchandising, and conversion optimisation. These investments optimise for the human browsing experience. For agent-mediated commerce, the storefront is largely irrelevant. The agent does not experience the UI. It queries the API directly.
This does not mean the storefront becomes worthless — human buyers still exist and matter. But it does mean that API quality, data completeness, and structured attribute coverage deserve investment commensurate with storefront UX investment. The commerce team that treats the API as a technical implementation detail of the storefront will be poorly positioned as agent-mediated commerce grows.
Trust and Authorisation for Autonomous Agents
An AI agent acting as a procurement assistant needs to be authorised to act on behalf of a specific buyer identity, within defined limits. Commerce APIs designed for agent access need robust, granular authorisation models: an agent authorised to browse and recommend should not automatically have authority to submit purchase orders above a defined threshold.
OAuth 2.0 flows with scope-based authorisation provide the technical foundation, but the commerce platform’s permission model must be granular enough to express meaningful agent constraints. “Can browse catalogue” and “can submit orders up to £5,000” are different authorisation scopes that agent-ready commerce platforms need to support.
Audit Trails for Autonomous Procurement
When a human buyer submits a purchase order through a browser interface, there is an implicit audit trail: the human logged in, navigated to a product, and confirmed the order. When an AI agent submits a purchase order, the provenance and reasoning behind the decision must be captured explicitly. Agent action logs, tool invocation records, and the data used to make recommendations become part of the procurement audit trail required by finance and compliance teams.
Commerce platforms integrating with AI agents should surface structured event data that supports these audit requirements — not as an afterthought, but as a first-class design concern.
Getting Agent-Ready: A Practical Starting Point
For B2B commerce teams that are not yet engaged with the agentic commerce paradigm, the barriers to entry are lower than they might appear. Composable architectures already provide most of the technical prerequisites. The work is largely about intentional design and data quality.
Audit your product data completeness. Identify the technical attributes that buyers and agents need to match products to requirements. Measure how completely those attributes are populated across the catalogue. Prioritise enrichment for the highest-volume and highest-value product categories.
Evaluate your API surface for agent accessibility. Review your existing commerce APIs against the design considerations for agent-mediated commerce: structured responses, stable contracts, unambiguous pricing endpoints, idempotent operations. Identify gaps that would create friction for agent integration.
Explore MCP server options. If you are running Elastic Path, evaluate the Composable Commerce MCP Server as an integration point for AI agents. Building agent connectivity on a standardised protocol reduces future maintenance burden and broadens compatibility.
Pilot with an internal use case. The fastest way to develop agentic commerce capability is to deploy an internal procurement agent — connecting your own AI assistant to your own commerce APIs for internal purchasing. Internal use cases allow experimentation without external customer risk and generate the operational learning that informs production deployment.
Working with McKenna Consultants
McKenna Consultants sits at the intersection of composable commerce architecture and AI integration — the two disciplines that agentic commerce requires in combination. Our Elastic Path expertise covers platform implementation, API design, catalogue data strategy, and integration architecture. Our AI capability spans agent design, MCP server implementation, and the enterprise governance frameworks that autonomous agents require.
If you are evaluating how to position your B2B commerce architecture for the agentic commerce paradigm — or if you have specific requirements around Elastic Path semantic search, MCP integration, or agent-ready API design — contact us to discuss your strategy.
Conclusion
Agentic commerce in B2B 2026 represents a genuine architectural inflection point, not a marketing term. The shift from human-navigated storefronts to AI agent-mediated product discovery changes what matters in commerce architecture: API quality, structured product data, semantic search capability, and agent-compatible authorisation models become as important as the storefront UX that has dominated investment for two decades.
The organisations that will capture the opportunity are those that design their commerce infrastructure to serve AI agents as first-class customers — not as an afterthought once the human-facing experience is optimised, but as a deliberate architectural priority. Composable architecture provides the foundation. Elastic Path’s MCP Server and semantic search capabilities provide the agent-facing integration layer. The strategic choices about product data quality, API design, and agent authorisation are yours to make now.
The buyers of the next decade will be both human and machine. Your commerce architecture needs to serve both.
