Why Your Product Feed Is An SEO Asset (And Who Should Own It) via @sejournal, @demirie

The product feed has historically been firmly in the domain of PPC teams, and for good reason. After all, for decades, feeds have been the basis for Shopping and the Paid side of this equation is where the biggest spend and revenue sit.

For an SEO, it was enough to check Google Search Console Shopping Results, and Bob’s your uncle.

Not anymore.

Product feeds have (not so) quietly become one of the most structurally important data assets in ecommerce – for paid, organic, and now agentic. They shape how Google interprets product pages across channels, how discrepancies between different product and category points get resolved, and increasingly, how AI evaluates and surfaces products to users.

The feed has outgrown single-team ownership because its surface area has expanded. And, SEO teams have been largely absent from the conversation.

The irony is hard to ignore: The industry is obsessing over duplicating our websites in markdown and llm.txt files while neglecting the one asset Google explicitly calls out in their new generative AI search guide as critical for product visibility in AI responses –  the Merchant Center (and by extension the feed).

This piece is about why that needs to change, what happens when we keep to the status quo, and what it looks like to put it into practice.

The Unholy Trinity: 3 Systems, 1 Goal

At last year’s Search Central Live, Google had a running joke about this. You add a standard to unify the standards, only to end up with an even bigger mess.

Rather than one unified system for understanding your products, Google is actually managing three distinct layers of data that have different rules, different structure, and, of course, different teams managing them on the organizational end.

First, you have the Product Feeds. These are the manual files you push to:

• The Google Merchant Center (GMC) contains your core attributes like titles, GTINs, and prices.
• The Manufacturer Center containing richer, more detailed product information

This is a parallel data structure that exists entirely independently of your website.

Next is the on-page structured data. This is most commonly JSON-LD markup tucked away in your code, designed mostly as a point of feed verification but also directly powering some of the ecommerce rich results. And, schema.org is also not the only player in town here. This came up repeatedly at Search Central Live last year, where Google explicitly referenced GS1, UN/CEFACT, and other ontologies.

Finally, there is the Website itself. This is the actual rendered page that a human sees or the machine-readable version that an agent sees, which it verified against the other two sources.

The friction comes from the fact that these systems play by different rules and are read differently by humans and machines.

Google is well aware that this setup is a headache. Back in 2024, they even discussed the possibility of unifying schema markup and feed data to simplify how merchants provide information. The goal was to move toward a more integrated processing system.

Until that unification actually happens, you are stuck managing three separate layers. And, that’s the issue.

Time and again, we see brands with feeds in complete disarray with schema that says something completely different and a website that contradicts both. This then forces Google (and agents) to make a judgment call.

Usually, that call doesn’t go in your favor.

Accuracy across all three isn’t just a “nice to have” anymore; it is the baseline for being discoverable and purchasable. And, a lack of harmony between them can sink your business results.

When It All Goes Wrong

Anyone working in ecommerce has seen a long list of issues that arise from this unholy trinity.

Some are easier to fix than others because they fall into a shared mental load between the teams. One excellent example of this is feed product titles. Time and time again, PPC managers use SEO-optimized titles to tweak their product feeds using rules or supplemental feeds. They understand that the SEO team has spent hours doing keyword research and tweaking the meta to fit search intent.

That kind of informal knowledge-sharing works well when the asset already sits within both teams’ remit.

When a PPC manager sees a disapproval spike, their diagnostic instinct naturally goes to feed attributes, quick website check, bid strategy, policy violations … all within their domain. And, that’s not a failure of skill; it’s a failure of scope. More often than not, they fix what they can see, escalate what they can’t to dev, and SEO never gets the call. Not because the structure failed, but because no single channel team has visibility across all three by default.

To illustrate the point, here are two recent examples from my agency of how this plays out in practice.

Schema, Feed & Website Misalignment

There are attributes that are nice to have and can help your products perform better on organic and paid listings.

For example, let’s say you are an ecommerce shop that also sells striped women’s dresses. On those products, you could use g:pattern in your feed and an equivalent Pattern Schema.org Property within Product schema type. Adding it to both might help you a bit when appearing for searches such as [striped women’s dress]. Or you might appear for those searches anyway. It’s likely that your website or feed/schema titles have some data on the pattern in the text anyway. Your products definitely won’t get disapproved in the GMC if you skip adding them to the feed or the schema.

Price is not one of those nice-to-have fields. It is an essential attribute in your feed, markup in your structured data, and information point on your website.

Recently, we have noticed across several ecommerce clients how much Google is cracking down on this. Products being disapproved in GMC left, right, and center because of the mismatch in price between the three layers.

One such example is our client working in office furniture, whose products started to be disapproved en masse recently.

Products like this one, where the website said £34.80, the price in the main feed was £34.80 GBP, and the Merchant decided the price was £33.54.

And, when we looked at the schema, we were faced with a 4th price of £29.

The schema markup on product pages was outputting the ex-VAT price rather than the inc-VAT final price, along with a priceValidUntil field.

Google uses schema to verify and sometimes overwrite feed prices via automatic item updates, which is why the wrong figure was showing in GMC and why all those products ended up on the disapproved list.

This is the kind of issue that only surfaces when someone has visibility across both systems.

And, this is an easy one to spot! Things get even more complex with fields that don’t have a direct schema equivalent or have different rules.

For example, fields such as availability.

In a GMC feed, Google accepts four standard values:

• In_stock
• Out_of_stock
• Preorder
• Backorder

Both preorder and backorder require an availability_date attribute –  the expected date the product will ship or be available.

On the schema.org side, the equivalent is the availability property on an Offer, which uses a different vocabulary:

and so on. If you’re managing these separately – feed in one team, schema in another – the chances of a mismatch are high.

Navigating the Variant Gap (item_group_id vs ProductGroup) is another example here and likely one of the most complex areas to align. Largely because feeds and structured data handle them through completely different architectures.

In a Google Merchant Center feed, product variants are submitted as a flat list, tied together by a shared item_group_id. On-page schema requires complex, nested parent-child relationships using the ProductGroup schema, alongside properties like hasVariant and variesBy.

Because an ecommerce site might have a feed that is massively larger than its indexable product pages, variant mapping will break down if the PPC team manages the flat feed while the SEO team builds the nested schema in isolation.

Infrastructure Failure

Price mismatches and schema conflicts are frustrating, but at least they’re visible. You can audit them, find the discrepancy, and fix it.

An infrastructure failure is different and, in some ways, more alarming because everything in your data can be perfectly aligned, and products will still disappear.

In one recent case, we saw a client’s products move from approved to not approved at scale almost overnight. The feed was fine. The schema was fine. The website was fine.

But a configuration change to the client’s CDN security settings had inadvertently begun blocking Google’s crawler. Bot protection rules, designed to defend the site, were treating Googlebot as a threat. With the website layer inaccessible, Google couldn’t verify it against the feed and schema data it already held, and with that verification broken, products were pulled.

While the fix was pretty straightforward, identifying the cause was definitely not. A PPC manager would have seen the disapproval. But, only someone thinking across crawl behavior, feed health, and site infrastructure simultaneously would have found the root cause.

SEO Case For Shared Feed Ownership

The old logic was simple: Merchant Center is primarily Paid Shopping, Shopping is PPC, therefore the feed is a PPC problem. This type of thinking is increasingly outdated.

Merchant Center handles paid and free listings, feeds impact rich results, the Google Shopping Graph, and now agentic ecommerce. It’s the infrastructure for your entire product presence. But infrastructure is only as good as the data running through it, and right now, too many feeds are riddled with issues.

Shared ownership isn’t a redistribution of credit. For PPC teams, it means fewer disapprovals to firefight, cleaner attribute data to optimize against, and a diagnostic partner.

SEOs need to be in the room when decisions are made because:

Feed Data Is Written For Databases, Not For Searchers

When SEOs aren’t involved in feed management, the feed stays as whatever the platform exports. And, that’s not always driven by search behaviors. Way too often, what the various feed plugins spit out are generic titles, approximate categorizations, and thin attributes.

This is the failure that doesn’t show up in the Merchant Center.

At best, PPC teams are quietly patching this with feed rules or supplemental feeds, both legitimate tools in the right context, with their own optimization logic, but neither designed to compensate for a primary feed that was never built with search intent in mind.

The feed is technically healthy, but if not dealt with,  it’s also commercially invisible.

Treating the feed as a search asset rather than a data asset means front-loading titles with high-intent keywords, refining taxonomy so products aren’t buried under generalized categories, ensuring attribute depth matches how customers actually filter and query, and maintaining the kind of ongoing hygiene that stops ghost products quietly disappearing from results.

These are things SEOs do instinctively elsewhere; they just rarely get asked to apply them here.

Structured Data Is The Hidden Variable Across Paid, Organic & Free Listings

When our clients’ price mismatch surfaced, my PPC team could see the disapproval. What they couldn’t see was why, because the answer was in the schema, and schema isn’t a PPC domain.

The blast radius also doesn’t stop at paid. The same schema error affects free listings, where Google pulls directly from GMCIn a GMC feed, Google accepts four standard values and applies the same validation logic.

And it affects organic rich results – price, availability, review count appearing in standard SERPs – which are driven by on-page structured data and carry no disapproval mechanism to flag when something is wrong. Incorrect information just surfaces silently.

I found this because I was in the room. If SEO isn’t co-owning the feed, there’s no reason anyone ever looks at the schema when paid goes wrong. And, no reason anyone connects the dots to what it’s doing to free listings and organic rich results at the same time.

Feed Quality Is Increasingly A Signal, Not Just A Campaign Requirement

Google has been explicit that Merchant Center feed quality affects more than Shopping ad eligibility. The overall health of a Merchant Center account (things like: disapproval rates, missing attribute warnings, policy compliance…) contributes to how Google evaluates a merchant’s trustworthiness as a data source. A feed with widespread attribute gaps or recurring disapprovals is a signal about data quality at scale, affecting eligibility and display across all Google surfaces. The feed is being read as a proxy for how reliable you are as a data source.

Google has also formalized this through the Shop Quality program, which evaluates merchants against each other across signals, including approval rates, shipping data completeness, and return policy clarity. Performing well here has a direct, visible impact on listings, with the Top Quality Store badge appearing on placements in both paid and organic results. This makes account health a competitive factor, not just a compliance one.

The Shopping Graph layer makes this even more consequential. The Shopping Graph now contains more than 50 billion product listings and feeds directly into AI Overviews, AI Mode, and Gemini. How reliably Google can verify and trust your product data determines your position within that graph.

To put it simply, consistency across structured data, landing pages, and Merchant Center feeds is what helps Google trust what it sees, and trust is the difference between an eligible, compelling listing and one that underperforms.

The Organic Stakes Are Changing

Organic Shopping has never been invisible to SEOs. We’ve worked on optimizing for organic shopping using strategies such as structured data and on-page elements, and reported on it via Google Search Console. We just didn’t pay much attention to the Merchant Center or the feed. And yet, this is what also powers those results.

SERP itself is also quietly restructuring around us.

The severity of this shift is brilliantly illustrated by ecommerce SEO expert Brodie Clark, who notes that Google’s search results are increasingly feeling like a product detail page in their own right. Rich results like visual product grids that take up prominent SERP real estate are cannibalizing branded search terms, particularly for brands stocked by major third-party retailers. The issue is compounded on mobile, where they can take up several scrolls before a brand’s own category pages appear at all.

This makes the feed an increasingly important data source behind a larger share of the commercial SERP.

Agentic Commerce Changes What ‘Discoverable’ And ‘Purchasable’ Mean

This is the part that’s easiest to underestimate, and where the stakes of feed neglect shift from significant to structural.

Discovery Is No Longer Only Human-Led

AI-powered surfaces like AI Overviews increasingly draw on Merchant Center data to surface products in response to commercial queries. A product with thin feed attributes and minimal structured data starts from a significant disadvantage at the discovery phase. Not just in Shopping, but in the AI layer being built on top of it.

This is no longer speculative. Google’s UCP documentation states explicitly that merchants should use their existing GMC account shopping feeds to capture high-intent customers during discovery, with UCP unlocking access to surfaces like AI Mode in Search and Gemini.

Google is already extending this further by introducing conversational commerce attributes in Merchant Center, such as compatibility, substitutes, related products, specifically designed to feed AI modes and reduce hallucinations.

Purchasability Is A Technical Problem, Not A Content One

Visibility is also only half the problem. If an AI agent then attempts to actually buy that product, it relies on a machine-readable representation of your site – the raw HTML, the accessibility tree, and rendered screenshots.

The accessibility tree is particularly interesting here. Your tree is a high-fidelity map distilling the page into the roles, names, and states of interactive elements. Non-semantic HTML,  i.e.,

What Google’s UCP Tells Us About Agent-Ready Websites via @sejournal, @slobodanmanic

Google’s Universal Commerce Protocol is the first production blueprint for what every website (ecommerce or not) will eventually need to expose to AI agents: discoverable actions, predictable outcomes, persistent sessions, and explicit agent policies.

UCP was released as infrastructure for Google Merchant Center retailers. But the more important story is the architecture underneath it. UCP is the first real implementation of what I’ve been talking about in the Interaction pillar of machine-first architecture. If you want to understand what agent-ready websites look like in practice, you need to look at UCP’s developer documentation. The architecture is the lesson, and it goes far beyond Google Shopping.

What Google Actually Built

UCP is an open standard Google unveiled in January 2026 at the National Retail Federation conference alongside Shopify, Etsy, Wayfair, Target, and Walmart, as a common language between AI surfaces (Gemini, Google AI Mode) and merchant backends. According to Google’s “Under the Hood” post on UCP, the protocol has four moving parts worth paying attention to.

A discovery endpoint at /.well-known/ucp. Agents query the /.well-known/ucp URL to learn what a merchant’s website can do, which products it sells, which actions it exposes, and which transports it supports. This manifest is the handshake between an AI agent and a merchant’s backend. Without that manifest, an agent has no knowledge of what it needs to parse or call. At best, it will try to guess.

Three REST endpoints for checkout. UCP reduces the entire transaction to three calls: Create a session, update a session, complete a session. That is it. No cart page, no address form, no confirmation screen. The checkout state lives in session responses, not in rendered HTML. Human layer of your website gets completely ignored. An interface will exist, but it will not be the one you designed.

Transport flexibility. UCP supports REST, Model Context Protocol (MCP) bindings, and A2A (Agent-to-Agent), so agents built on different stacks can talk to the same merchant backend without custom adapters. An agent running inside Gemini and an agent running on a custom MCP client can both hit the same UCP endpoints. This was a very smart move.

An open specification at ucp.dev. UCP is published as an open spec any website, AI platform, or merchant platform can implement. Google does not own the protocol or its governance. The openness matters because the architecture becomes portable to any website outside Google Merchant Center, even if Google’s onboarding path does not.

Google is building UCP for its own Shopping ecosystem first. UCP’s design is the real lesson for everyone else, and that design is a textbook implementation of the Interaction pillar of machine-first architecture. Shopping carts are abandoned by roughly 70% of humans (per Baymard Institute’s long-running checkout research). You can expect the agent abandonment rate on websites with no Interaction layer to be closer to 100%.

For UCP’s place in the broader agentic commerce landscape, alongside OpenAI and Stripe’s ACP, Shared Payment Tokens, and the platforms already selling through AI agents, see Selling to AI: The Complete Guide to Agentic Commerce. For the specific capabilities Google shipped in March 2026 (Cart, Catalog, and Identity Linking), see Google’s UCP Update: Carts, Catalogs, and Loyalty in AI Shopping.

UCP Is The Interaction Pillar In Production

The Interaction pillar of machine-first architecture describes what a website must expose so an AI agent can accomplish a goal on it. Five properties: discoverable actions, predictable outcomes, workflow continuity, error recovery, and agent policies. UCP maps to each one almost perfectly.

Discoverable actions. The Interaction pillar says agents need a machine-readable index of what they are allowed to do on a page before they try to do it. UCP’s /.well-known/ucp capability manifest is exactly the machine-readable action index the Interaction pillar calls for, shipped as a production endpoint. An agent fetches the manifest, reads the list of available operations, and plans its next step. No trial and error, no DOM scraping.

Predictable outcomes. The Interaction pillar says every action should return machine-readable state (computed totals, allocated inventory, success flags), not a 200 OK with an HTML receipt. UCP session responses carry structured data at every step: pricing breakdowns, discount allocations, and explicit session state. An agent reading a UCP response knows exactly what just happened and what it owes next.

Workflow continuity. The Interaction pillar says agents need stable session references that survive across multi-step workflows, so they do not lose context mid-task. UCP sessions have persistent IDs, and PUT updates carry that ID forward. An agent can add a line item, apply a discount, adjust shipping, and complete the order across multiple calls without re-creating state.

Error recovery. The Interaction pillar says failures should return structured alternatives, not dead ends. When a UCP discount code fails, the session response explains why and surfaces alternatives the agent can try. A human might click “try again.” An agent needs a payload that tells it what to do next.

Agent policies. The Interaction pillar says websites should declare what agents are allowed to do, what requires human confirmation, and what is off-limits entirely. UCP’s capability declarations are that policy layer: A merchant signals which actions agents can invoke, under what conditions, and where human approval is required. Request signatures and tokenized payments enforce the policy at the protocol level.

Google’s /.well-known/ucp endpoint is the Interaction pillar’s “discoverability of actions” being shipped as production infrastructure. Agents query it to learn what a website can do before they attempt to do it. UCP requires three REST endpoints for checkout: session creation, updates, and completion. That is the entire Interaction pillar reduced to three API calls.

The Gap UCP Exposes For Everyone Else

UCP is Google’s answer to the agent-traffic gap inside its Shopping ecosystem. Every non-UCP website still has the gap, though not every retailer agrees on where the gap actually lives.

Breanna Fowler, Dell’s Head of Global Consumer Revenue Programs, told Digital Commerce 360 in an April 2026 interview that she has not yet noticed “anything behaviorally consistent” in the agent traffic reaching Dell.com. Her focus is search and discoverability, not agent-specific infrastructure: “If I can’t find your products easily and effortlessly, no amount of content and configurator capabilities, nobody really gives a crap about that stuff.”

Fowler is right that nothing matters if agents cannot find the product. But for an AI agent, “finding” a product does not mean typing into a search box. Finding means querying a capability manifest, reading a structured product catalog, and invoking a discoverable action. In a human-first website, findability is a UI problem. In an agent-ready website, findability is a protocol problem. UCP exists because Google decided that treating findability and checkout as protocol problems, not UI problems, is the only way agent conversions ever scale.

A Gemini agent shopping through a UCP-enabled merchant does not parse a product grid, does not guess at form fields, and does not hope nothing re-renders under it. The agent queries /.well-known/ucp, reads the capability manifest, and advances the session through UCP’s three checkout endpoints. The rest of the web (every SaaS dashboard, every B2B quote flow, every booking system, every subscription portal) has no equivalent protocol coming to rescue it.

Baymard Institute’s aggregated checkout research puts the human cart abandonment rate at 70.22% across 50 studies. The agent abandonment rate on websites without an Interaction layer is closer to 100% because humans hesitate at checkout, while agents cannot even find checkout.

What Every Website Can Learn From UCP’s Architecture

You do not need to implement UCP. You are probably not even a commerce business. UCP’s architecture still generalizes into five principles any agent-ready website should implement: a capability manifest, structured actions, machine-readable state, persistent sessions, and an explicit agent policy.

1. Publish a capability manifest. Agents need to know what your website can do before they start. That manifest might be a /.well-known/ endpoint, an llms.txt file, a WebSite schema node with potentialAction entries, or an MCP server listing available tools. The format matters less than the existence. If there is nothing for an agent to query, the agent has to guess, and guessing is how conversions die.

2. Expose actions as structured data. Schema.org has supported Actions for over a decade, including BuyAction, OrderAction, ReserveAction, SubscribeAction, and SearchAction. Almost no websites use them. UCP’s POST /sessions endpoint is effectively a BuyAction target given a stable API contract, which is what schema.org Actions have needed for a decade to actually work. Any website can do the same on its own actions: declare the action type, name the endpoint, document the payload. The how AI agents see your website post covered the Structure pillar side of this question. Schema.org Actions are the Interaction pillar side.

3. Return machine-readable state at every step. Every response to an agent should carry structured state the agent can parse: what happened, what changed, what is next. HTML confirmation pages are not machine state. A redirect to /thank-you is not machine state. JSON with named fields and explicit flags is machine state. Returning JSON state instead of HTML confirmation pages is the single biggest architectural shift from human-first design to agent-ready design.

4. Design for sessions, not pageviews. Agents do not restart when they get distracted. They come back to a workflow in progress and expect the state to still be there. Sessions with stable IDs, safe-to-retry updates, and graceful resume paths are not optional for agents; they are the base layer. Pageview analytics trained a generation of product teams to think in discrete hits. Agents think in transactions.

5. Declare your agent policy explicitly. An agent policy defines three things: what agents can do without asking a human, what requires human confirmation, and what is off-limits entirely. UCP answers these questions through capability declarations. Your website can answer them through an AGENTS.md file, a /.well-known/ policy endpoint, or structured annotations. Pick one. Publish it. Guessing a policy is how agents end up taking actions their users did not intend.

None of these principles require Google’s participation. None require UCP’s adoption. They require a decision to treat a website as an API surface for agents in addition to a screen for humans.

Citation Gets You Into The Answer. Actions Get You Into The Revenue

Most of the AXO conversation today is still about the Content pillar: how to get cited in ChatGPT answers, how to rank in Google AI Overviews, how to become the source AI surfaces quote. That work matters. Citation drives awareness, and awareness is the top of the funnel. The SEO to AAIO and Answer Engine Optimization articles covered how to win it.

UCP demonstrates the Interaction pillar, which is the other half of the agent-ready website stack that AEO and GEO do not cover. The Interaction pillar is about being transacted through by an AI agent, not quoted in its answer. The difference between a cited website and a transactable website is the Interaction pillar. Citation gets you into the AI’s answer. Discoverable actions get you into the AI’s revenue.

On the Cheeky Pint podcast, Sundar Pichai described a future where an AI user has “many threads running” at the same time, research, comparison, booking, purchase, all executing in parallel on behalf of a single human. In that model, the website that lets the agent resolve its thread fastest wins the thread. Resolution means completing an action, not loading a page. Dell has the traffic and loses the thread. A UCP-enabled merchant resolves the same thread in three API calls.

UCP is the first production artifact that gets the Interaction pillar right. UCP will not be the last. Every website that wants to participate in agent-mediated revenue will eventually need to ship its own version of the same architecture, through an open protocol, a schema.org capability layer, a WebMCP endpoint, or a custom MCP server. The spec can vary even if the principles cannot.

UCP is the working reference implementation of the Interaction pillar, built by Google and running in production inside Google Shopping today. Every other website still owes its own answer. Dell’s Breanna Fowler said discoverability is what matters. For an agent, discoverability is a protocol.

More Resources:

This post was originally published on No Hacks.

Featured Image: Natalya Kosarevich/Shutterstock

Selling To AI: The Complete Guide To Agentic Commerce via @sejournal, @slobodanmanic

For 30 years, checkout has been a page. A form with fields for name, address, credit card number. Whether it was Amazon’s one-click patent or Apple Pay’s fingerprint, the innovation was always about making that form faster to get through.

The form itself never went away. Now it is.

This is the final article in a five-part series on optimizing websites for the agentic web. Part 1 covered the evolution from SEO to AAIO. Part 2 explained how to get your content cited in AI responses. Part 3 mapped the protocols forming the infrastructure layer. Part 4 got technical with how AI agents perceive your website. This article covers the commerce layer: how AI agents find products, complete purchases, and handle payments without ever loading a checkout page.

In September 2025, Stripe and OpenAI launched Instant Checkout inside ChatGPT. In January 2026, Google and Shopify unveiled the Universal Commerce Protocol at the National Retail Federation conference. Two open standards. Two competing visions for the same shift: checkout becoming a protocol, not a page.

Throughout this article, we draw exclusively from official documentation, research papers, and announcements from the companies building this infrastructure.

How We Got Here

Every generation of commerce technology has solved the same problem: reducing the friction between “I want something” and “I have it.” Agentic commerce is not a break from this pattern. It’s the pattern’s logical conclusion.

1994: The first online purchase. On Aug. 11, 1994, Phil Brandenberger used his credit card to buy Sting’s Ten Summoner’s Tales CD for $12.48 from a website called NetMarket. The New York Times covered it the next day. NetMarket’s 21-year-old CEO, Daniel Kohn, told the paper: “Even if the N.S.A. was listening in, they couldn’t get his credit card number.” Netscape’s SSL protocol, released that same year, made it possible.

The friction removed: You no longer had to go to a physical store.

Late 1990s: Comparison shopping. Within a few years, websites like BizRate (1996), mySimon (1998), and PriceGrabber (1999) let buyers see prices across multiple merchants instantly. Google entered the space in 2002 with Froogle, later renamed Google Product Search in 2007, then Google Shopping in 2012.

The friction removed: You no longer had to visit each store to compare.

1998: The store adapts to you. Amazon deployed item-to-item collaborative filtering at scale, the algorithm behind “customers who bought this also bought.” Greg Linden, Brent Smith, and Jeremy York published the underlying research in IEEE Internet Computing in 2003. In 2017, the journal named it the best paper in its 20-year history.

The friction removed: You no longer had to know exactly what you wanted.

2015: Commerce moves into conversations. Chris Messina, then Developer Experience Lead at Uber, coined the term “conversational commerce” in a January 2015 Medium post, describing “delivering convenience, personalization, and decision support while people are on the go.” In April 2016, Mark Zuckerberg launched the Facebook Messenger Platform, declaring: “I’ve never met anyone who likes calling a business.” Meanwhile, in China, WeChat had already proved the model. Its Mini Programs, launched January 2017, generated 800 billion yuan (~$115 billion) in transactions by 2019.

The friction removed: You no longer had to open a store’s website.

2014-2023: Voice and social commerce. Amazon Echo launched in November 2014, promising you could buy things without a screen. The promise was mostly unfulfilled. Social commerce had better luck: TikTok Shop, launched in the U.S. in September 2023, reached $33.2 billion in global sales by 2024. Content became the storefront.

The friction removed: Purchase intent was created inside the feed, not searched for.

2024: AI starts shopping for you. Within months, every major platform launched AI shopping features. Amazon introduced Rufus in February, a conversational assistant trained on its product catalog. Google rebuilt Shopping with AI in October, drawing on 50 billion product listings. Perplexity launched “Buy with Pro” in November, turning a search engine into a store.

The friction removed: AI did the research, comparison, and recommendation for you.

2025: The buyer disappears. In January, OpenAI launched Operator, an agent that navigated websites, filled forms, and completed purchases autonomously. In May, Google announced “Buy for Me” at I/O 2025. In September, Instant Checkout went live in ChatGPT.

The friction removed: The last one. The human no longer needs to be there for the transaction to happen.

Each of these shifts was about the same thing: removing one more step between wanting and having. Agentic commerce removes the final step: doing it yourself.

Checkout Is No Longer A Page

Here’s the shift in one sentence: In traditional commerce, the seller builds the checkout experience. In agentic commerce, the agent does.

When you buy something on a website today, you interact with the merchant’s checkout page. They designed the form, they chose the layout, they control the flow. You fill in your details, click “Buy,” and the payment processes.

In agentic commerce, the AI agent presents the checkout information within its own interface. ChatGPT shows you the product, the price, the shipping options, within the chat. You confirm. The agent handles the rest. The merchant never renders a page. They receive an API call.

Stripe’s agentic commerce guide puts it directly: “The parts of commerce that used to be user experience problems are becoming protocol problems.” Instead of optimizing button colors and form layouts, merchants are defining API endpoints and product feeds. Discovery, comparison, and checkout are all handled by the agent. The merchant’s job shifts to supplying structured product data and processing the order.

Emily Glassberg Sands, Stripe’s Head of Information and Data Science, framed the broader implications: “Agents don’t just change who’s at the checkout. They change who’s doing the searching, the deciding, the trusting. All of it.”

I discussed this with Jes Scholz, who ran digital across 140+ ecommerce brands at Ringier, on the podcast. Her experience was clear: Agents browse in text mode, and if they can’t parse your site cleanly, they leave. No second chances.

This isn’t theoretical. As of February 2026, several agentic commerce implementations are live. ChatGPT Instant Checkout is available to U.S. users on Free, Plus, and Pro plans. Etsy, Instacart, and Walmart are among the merchants processing orders through it. Shopify’s Agentic Storefronts are active by default for eligible merchants, syndicating products to ChatGPT, Google AI Mode, Microsoft Copilot, and Perplexity simultaneously. Perplexity launched Instant Buy with PayPal in November 2025, allowing purchases directly within the chat interface with merchants like Wayfair, Abercrombie & Fitch, and thousands more via BigCommerce and Wix.

Every major AI company is moving in this direction. Anthropic, the company behind Claude, has been equally explicit about its commerce plans. In February 2026, Anthropic confirmed it is building features for “agentic commerce, where Claude acts on a user’s behalf to handle a purchase or booking end to end,” while committing to keeping the experience ad-free with no sponsored links or third-party product placements. Claude already connects to Stripe, PayPal, and Square via MCP integrations. And in June 2025, Anthropic published Project Vend, a research experiment where Claude autonomously operated a physical retail store for a month, managing inventory, pricing, supplier relations, and customer interactions. The results were instructive: The agent performed well at supplier discovery and customer service, but sold items at a loss and hallucinated payment details. A useful preview of both the potential and the current limitations.

Two open protocols are making this possible. Both launched within four months of each other.

The Agentic Commerce Protocol

The Agentic Commerce Protocol (ACP) is an open standard co-developed by OpenAI and Stripe, announced Sept. 29, 2025. Licensed under Apache 2.0, it defines how AI agents complete purchases on behalf of users.

ACP uses a four-party model: the buyer (discovers and approves), the AI agent (presents products and handles checkout UI), the merchant (processes the order and payment), and the payment service provider (handles payment credentials securely). The merchant remains the merchant of record. They process the payment, handle fulfillment, manage returns. The agent is an intermediary, not a marketplace.

The protocol defines four API endpoints:

The responsibility shift is worth spelling out:

The agent handles what the buyer sees. The seller handles what happens after they click “Buy.” ACP can be implemented as either a REST API or an MCP server, connecting naturally to the protocol ecosystem covered in Part 3.

Stripe’s Agentic Commerce Suite, launched Dec. 11, 2025, makes ACP adoption practical. Ahmed Gharib, Stripe’s Product Lead for Agentic Commerce, described it as “a low-code solution enabling businesses to sell across multiple AI agents via a single integration.” Without it, connecting to each AI agent individually would take up to six months of bespoke engineering per platform.

The Suite has three components: product discovery (sync your catalog and Stripe distributes it to AI agents), checkout (powered by Stripe’s Checkout Sessions API, handling taxes and shipping), and payments (using Shared Payment Tokens and Stripe Radar for fraud detection). Merchants connect their existing product catalog or upload directly to Stripe, then select which AI agents to sell through from the Stripe Dashboard.

The ecosystem is growing quickly. Beyond OpenAI, Stripe lists Microsoft Copilot, Anthropic, Perplexity, Vercel, and Replit as AI platform partners. On the ecommerce side, Squarespace, Wix, WooCommerce, BigCommerce, and commercetools have integrated. Salesforce announced ACP support in October 2025. Shopify’s 1 million+ US merchants are coming soon.

The Universal Commerce Protocol

Four months after ACP launched, a different coalition unveiled a second standard.

The Universal Commerce Protocol (UCP) was co-developed by Shopify and Google, announced Jan. 11, 2026 at the National Retail Federation conference in New York. Google CEO Sundar Pichai presented it. The co-developers include Etsy, Wayfair, Target, and Walmart. Over 20 companies endorsed it at launch, including Mastercard, Visa, Best Buy, Home Depot, Macy’s, American Express, and Stripe. I broke down UCP and its strategic implications the week it launched on the podcast.

Where ACP is tightly focused on the checkout flow, UCP is designed as a full commerce standard covering discovery through post-purchase. Its architecture is modeled after TCP/IP, with three layers:

UCP is protocol-agnostic. It supports REST, MCP, A2A, and AP2 (Agent Payments Protocol, Google’s standard for agent-initiated payments). ACP currently supports REST and MCP.

Discovery works through a published profile at /.well-known/ucp, similar to how A2A agents publish their capabilities at /.well-known/agent-card.json (covered in Part 3). Both agents and merchants declare their capabilities, and on each request, the system computes the intersection of what they can do together. Ashish Gupta, VP/GM of Merchant Shopping at Google, described the logic: “The shift to agentic commerce will require a shared language across the ecosystem.”

The two protocols reflect different strategic positions. ACP, built by the company running the AI agent (OpenAI) and the company processing the payment (Stripe), is optimized for getting transactions through ChatGPT quickly. UCP, built by the company hosting the merchants (Shopify) and the company running search (Google), is designed for a multi-agent future where many AI platforms compete for the same shoppers.

The good news for merchants: These aren’t mutually exclusive. Shopify merchants can serve both simultaneously. The same products appear in ChatGPT via ACP and in Google AI Mode via UCP. Shopify’s Agentic Storefronts handle the multi-protocol complexity, syndicating catalog data across ChatGPT, Google AI Mode, Microsoft Copilot, and Perplexity from a single admin panel.

Vanessa Lee, Shopify’s VP of Product, framed the company’s position: “Agentic commerce has so much potential to redefine shopping and we want to make sure it can scale.”

The Trust Problem: Payments Without People

Both protocols face the same foundational challenge: How do you process a payment when the person with the credit card isn’t the one at the checkout?

Traditional commerce treats credential possession as a trust signal. If you have the card number, the expiry date, and the CVV, you’re probably the cardholder. Agentic commerce breaks this assumption. The agent has been authorized to act on the buyer’s behalf, but it’s not the buyer. As Stripe’s Kevin Miller wrote in his October 2025 blog post: “Trust can’t be inferred. It has to be explicitly granted, scoped, and enforced in code.”

Javelin Strategy & Research, cited by Visa, describes this as the shift from “card-not-present” to “person-not-present” transactions. It’s a useful framing. Card-not-present fraud was the defining challenge of ecommerce. Person-not-present fraud is the defining challenge of agentic commerce.

Shared Payment Tokens

Stripe’s solution is the Shared Payment Token (SPT), a new payment primitive designed specifically for agent transactions. Here’s how it works:

1. The buyer saves a payment method with the AI platform (e.g., ChatGPT).
2. When approving a purchase, the AI platform issues an SPT scoped to the specific merchant, capped at the checkout amount, with a time limit.
3. The AI platform sends the SPT to the merchant via ACP.
4. The merchant creates a Stripe PaymentIntent using the token.
5. Stripe processes the payment, applying fraud detection in real time.

The buyer’s actual card details are never shared with the merchant or the agent. Each token is programmable (scoped by merchant, time, and amount), reusable across platforms, and revocable at any time. For existing Stripe merchants, enabling SPTs requires “as little as one line of code.”

The Payment Networks Respond

The card networks have launched their own standards. Visa introduced the Trusted Agent Protocol in October 2025, an open framework built on HTTP Message Signatures that helps merchants distinguish legitimate AI agents from malicious bots. Developed in collaboration with Cloudflare, it has feedback from Adyen, Checkout.com, Microsoft, Shopify, Stripe, and Worldpay, among others.

Mastercard launched Agent Pay in April 2025, introducing “Agentic Tokens” that build on its existing tokenization infrastructure. Each agent action uses permissions and limits defined by the consumer. Mastercard CEO Michael Miebach described agent-led payments as a “significant paradigm shift” for the industry. U.S. issuers were enabled in November 2025, with global rollout in early 2026.

PayPal joined the ACP ecosystem on October 28, 2025, enabling PayPal wallets for ChatGPT checkout and building an ACP server that connects its global merchant catalog without requiring individual merchant integrations.

Google launched its own payment standard in parallel. The Agent Payments Protocol (AP2), announced September 2025 with 60+ industry partners, uses Verifiable Digital Credentials and a cryptographic Mandate system to create tamper-evident proof of user consent at every step of the transaction. AP2 is payment-agnostic, supporting credit and debit cards, real-time bank transfers, and even stablecoins via a Coinbase x402 extension. It’s integrated directly into UCP.

Fraud Without Fingerprints

Traditional fraud detection relies on human behavioral signals: mouse movements, typing patterns, browsing behavior, session duration. AI agents have none of these. A legitimate agent transaction can look indistinguishable from a sophisticated bot attack.

Stripe addressed this by building what they describe as “the world’s first AI foundation model for payments,” a transformer-based model trained on tens of billions of transactions. The model treats each charge as a token and behavior sequences as context, ingesting signals including IPs, payment methods, geography, device characteristics, and merchant traits. When SPTs are used, Stripe Radar relays risk signals including dispute likelihood, card testing detection, and stolen card indicators to help “differentiate between high-intent agents and low-trust automated bots.”

The attack surface is also novel. Researchers demonstrated in a June 2025 study that ecommerce agents are susceptible to visual prompt injection: malicious content embedded in product listings can hijack agent behavior during shopping tasks. All agents tested were vulnerable. A separate study accepted to IEEE S&P 2026 found that 13% of randomly selected ecommerce websites had already exposed their chatbot plugins to indirect prompt injection via third-party content like product reviews. And a January 2025 paper on authenticated delegation argues that for agentic commerce to function at scale, the industry needs standardized mechanisms to “explicitly delegate authority to agents, transparently identify those agents as AI, and enforce human-centered choices around security and permissions.” SPTs, the Trusted Agent Protocol, and Agent Pay are all early answers to that challenge.

The concern is real on the consumer side, too. 88% of consumers surveyed by Javelin are concerned that AI will be used for identity fraud, according to Visa’s analysis. Building trust infrastructure that works for agent transactions is the prerequisite for agentic commerce scaling beyond early adopters.

→ Read More: Trust In AI Shopping Is Limited As Shoppers Verify On Websites

Who’s Already Selling to AI

Despite the infrastructure still being built, adoption is moving fast.

AI platforms with commerce capabilities:

Merchants and brands on board:

The early adopter list reads like a mall directory. URBN (parent of Anthropologie, Free People, and Urban Outfitters), Etsy, Coach, Kate Spade, Glossier, Vuori, Spanx, SKIMS, Ashley Furniture, Revolve, and Halara are among those onboarding to Stripe’s Agentic Commerce Suite. Walmart and Instacart are live on ChatGPT. Gymshark, Everlane, and Monos are live on Google AI Mode via UCP.

Ecommerce platforms enabling it:

Shopify’s 1 million+ U.S. merchants are eligible for ChatGPT integration. BigCommerce, Wix, Squarespace, WooCommerce, and commercetools have integrated with Stripe’s Suite. Salesforce Commerce Cloud announced ACP support in October 2025, with new Agentforce agents for merchant, buyer, and personal shopper workflows.

The Market

The market projections vary widely, which tells you how early we are. McKinsey projects $1 trillion in U.S. retail revenue orchestrated by agents by 2030, scaling to $3-5 trillion globally. Gartner predicts 90% of B2B purchases will be handled by AI agents within three years, intermediating $15 trillion in spending by 2028. Forrester predicts that by 2026, one-third of retail marketplace projects will be deserted as answer engines steal traffic.

The consumer side is more cautious. A Contentsquare survey of 1,300 U.S. consumers found 30% willing to let an AI agent complete a purchase on their behalf. A YouGov survey of 1,287 U.S. adults found 65% trust AI to compare prices, but only 14% trust it to actually place an order. Among Gen Z, that number rises to 20%. The gap between “I’ll let AI help me shop” and “I’ll let AI buy for me” is where we are right now.

But the traffic is already there. AI-driven traffic to U.S. retail websites grew 4,700% year-over-year by mid-2025, according to Adobe Analytics. Shopify reported that orders attributed to AI searches grew 11x since January 2025. OpenAI estimates approximately 2% of all ChatGPT queries are shopping-related, roughly 50 million shopping queries daily across a user base of 700 million weekly users.

Academic research is starting to reveal what happens when agents do the buying. A Columbia Business School and Yale study (August 2025) introduced ACES, the first agentic ecommerce simulator, and tested six frontier models, including Claude and GPT-4. They found that AI shopping agents exhibit “choice homogeneity,” concentrating demand on a small number of products and showing strong position biases in how listings are ranked. The researchers warn of winner-take-all dynamics and the emergence of “AI-SEO,” where sellers optimize listings specifically for agent behavior rather than human preferences. A February 2026 study on personalized product curation found that current agentic systems remain “largely insufficient” for tailored product recommendations in open-web settings. The agents are getting better at buying. They’re not yet great at buying the right thing for a specific person.

The infrastructure is being built regardless of whether consumers are fully ready. When they are, the businesses that are prepared will be the ones the agents can find.

How To Get Started

The good news: For most businesses, the entry point is simpler than you’d expect.

If you’re on Shopify, you may already be selling to AI. Agentic Storefronts are active by default for eligible U.S. merchants. Your products are syndicated to ChatGPT, Google AI Mode, Microsoft Copilot, and Perplexity from your existing Shopify admin. Check your dashboard for the agentic channel settings and ensure your product data (descriptions, images, categories) is clean and complete.

If you’re on Stripe, enabling Shared Payment Tokens for ACP requires as little as one line of code. The Agentic Commerce Suite handles catalog syndication, checkout, and fraud detection. Connect your product catalog, select which AI agents to sell through, and you’re live.

If you’re on BigCommerce, Wix, Squarespace, or WooCommerce, integrations with Stripe’s Suite are available. BigCommerce described the shift from “months of bespoke engineering work” per AI platform to “a single, configurable integration.”

Regardless of platform, the protocol integrations get you connected. But agents still need to find and understand your products. This is where the work from Part 2 (getting cited) and Part 4 (being agent-readable) converges with commerce.

Audit your product data. Agents parse your catalog programmatically. Every product needs:

• A descriptive, specific title (“Men’s Organic Cotton Crew Neck T-Shirt, Navy,” not “Blue Shirt”).
• A complete description including materials, dimensions, care instructions, and use cases.
• Accurate, real-time pricing and stock availability.
• High-quality images with descriptive alt text.
• Consistent categorization across your catalog.

Add structured markup. At minimum, every product page should include Product schema with name, description, image, sku, and brand, plus nested Offer schema with price, priceCurrency, availability, and seller. If you have reviews, add AggregateRating. This is the machine-readable layer that agents parse when direct protocol integrations aren’t available. I talked about this with Duane Forrester, who co-launched Schema.org while at Bing, on the podcast. His argument: consistent structured data builds what he calls “machine comfort bias,” where AI systems develop a preference for sources that have proven reliable over time.

Test your agent visibility. Open ChatGPT, Perplexity, and Google AI Mode, and ask them to recommend products in your category. If yours don’t appear, agents can’t sell them. View your product pages in reader mode or a text-based browser to see what agents see when they visit your site directly (covered in Part 4).

Track agent-driven traffic. ChatGPT appends utm_source=chatgpt.com to referral links. Perplexity and other AI platforms leave similar referral signatures. Set up segments in your analytics to isolate AI-referred visits and monitor conversion rates separately from human traffic. The numbers are small now, but the 4,700% year-over-year growth in AI traffic to retail means they won’t stay small.

Walmart CEO Doug McMillon put it directly: “For many years now, ecommerce shopping experiences have consisted of a search bar and a long list of item responses. That is about to change.”

Whether it changes next quarter or next year for your business depends on whether your product data is ready when the agents come looking.

Key Takeaways

• Checkout is becoming a protocol, not a page. In agentic commerce, the AI agent handles the interface; the merchant processes the order. Two open standards, ACP (Stripe + OpenAI) and UCP (Shopify + Google), define how this works.
• Both protocols are open and growing fast. ACP launched in September 2025 and powers Instant Checkout in ChatGPT. UCP launched in January 2026 with endorsements from Mastercard, Visa, Walmart, and Target. They’re complementary, not mutually exclusive. Shopify merchants can serve both simultaneously.
• Shared Payment Tokens solve the “person-not-present” problem. When the buyer isn’t at the checkout, traditional trust signals break down. SPTs are programmable, scoped, time-limited, and revocable, letting agents initiate payments without ever seeing the buyer’s card details.
• Payment networks are building their own standards. Visa’s Trusted Agent Protocol and Mastercard’s Agent Pay provide authentication and fraud frameworks specific to agent transactions. PayPal joined the ACP ecosystem. The payments infrastructure for agentic commerce is taking shape across the industry.
• Major brands are already live. Etsy, Walmart, Instacart, Glossier, SKIMS, Coach, and dozens more are selling through AI agents today. Ecommerce platforms, including Shopify, BigCommerce, Wix, Squarespace, and WooCommerce, have integrations available.
• Consumer trust is lagging behind infrastructure. Only 14% of consumers currently trust AI to place orders on their behalf. But AI-driven traffic to retail grew 4,700% in a year. The infrastructure is being built for the adoption curve that follows.

This is the final article in a five-part series on the agentic web. Part 1 framed the shift from SEO to AAIO. Part 2 covered how to get cited by AI. Part 3 mapped the protocols. Part 4 explained how agents perceive your website. This article covered where it all leads: transactions.

The thread connecting all five parts is straightforward. Structured data helps AI find you. Clean content helps AI cite you. Accessible HTML helps AI navigate you. Structured commerce protocols help AI buy from you. It’s the same principle at every layer: Make your business machine-readable, and the machines will do business with you.

Kevin Miller, Stripe’s Head of Payments, captured the moment: “Stripe spent the last 15 years optimizing commerce for human shoppers. Now, we’re starting to do the same with agents.”

The agents are already shopping. The question is whether they can find your store.

More Resources:

This post was originally published on No Hacks.

Featured Image: showcake/Shutterstock