Agentic Commerce in 2026: When AI Shopping Bots Buy for Users — How Brands Stay Discoverable and Purchasable

Visa wired payments directly into ChatGPT. That sentence should make every e-commerce director stop scrolling.

This isn't a demo. It's not a roadmap slide from some conference. Visa enabled autonomous AI agents to complete purchases inside ChatGPT — research, compare, select, pay — without a human touching the checkout button. Mastercard launched its own agent payment rail. OpenAI and Stripe are building the Agentic Commerce Protocol (ACP) for the checkout layer. Google and others are backing AP2 for spend authorization. The payment infrastructure for agent-driven commerce is live. Multiple rails. Multiple platforms. Real money moving.

Which means the bottleneck has shifted. Payments aren't the problem anymore. The problem is whether your product data can be found, read, and trusted by an AI agent that's deciding which 2–3 options to surface to its user.

If the agent can't parse your feed, you don't appear in the short list. You don't lose the sale to a competitor with a better price. You never enter the consideration set. That's what agentic commerce means for brands in 2026: a new gatekeeper that doesn't browse, doesn't impulse-buy, and doesn't care about your hero image.

What Agentic Commerce Actually Is

Conversational commerce was ChatGPT saying "here's a good waterproof jacket" and you clicking through to buy it. Agentic commerce is you telling ChatGPT "find me a waterproof jacket under $150, best-reviewed, and order it" — and the agent doing all of it. Research across multiple retailers. Compare specs, prices, reviews, delivery times. Execute the purchase. Maybe even handle returns later.

The agent isn't a recommendation engine. It's a procurement officer with a budget and a brief. It works on behalf of a human, but the human only sees the outcome: a short, pre-checked, purchasable list of 2–3 options, or in some cases, a completed order waiting for confirmation.

This is the next evolution after search commerce (Google Shopping) and social commerce (Instagram checkout). But it's fundamentally different because the decision-maker and the purchaser are no longer the same entity. The AI agent is your second customer — it discovers, evaluates, and decides before the human ever sees your brand.

The Payment Infrastructure Is Already Live

Here's what's actually running right now, not projected or rumored:

• Visa Intelligent Commerce — Visa's official name for its agent payment integration with ChatGPT. Enables autonomous transactions where the agent holds delegated payment credentials. (Note: some sources reference this as "Visa Trusted Agent" — the official branding appears to be Visa Intelligent Commerce, but verify for your own reporting.)
• Mastercard Agent Pay — Mastercard's competing rail for agent-initiated purchases. Same concept: delegated authority for AI agents to transact on behalf of cardholders.
• ACP (Agentic Commerce Protocol) — The checkout layer protocol. Covers how an agent selects a product, initiates a cart, and completes a transaction. Currently maintained by OpenAI with Stripe involvement. (Source attribution varies on whether Stripe is a co-maintainer or integration partner — verify the exact governance before citing in formal contexts.)
• AP2 (Agent Payment Protocol) — The spend authorization layer. How an agent gets permission to spend a user's money up to defined limits. Backed by Google and others. (One source claims AP2 is now under the FIDO Alliance — this governance claim needs independent verification.)
• MCP (Model Context Protocol) adoption — Google, Microsoft, OpenAI, Visa, and Mastercard are all adopting MCP for how agents connect to external tools and data sources. This is the plumbing that lets agents query product catalogs, check inventory, and pull pricing in real time.

Additional rails have been mentioned — Amazon's "Buy for Me" feature, Coinbase's agent.market on the x402 protocol — but these appear in only one source and need independent verification before you rely on them in strategy decisions.

Two things I want to flag that aren't confirmed yet: Google's "Universal Cart" concept and specific Shopify agent commerce features. Both were referenced in early discussions of this topic, but no source I've found documents what's actually launched. Treat them as directional signals, not proof points.

The bottom line: payment rails exist. Checkout protocols exist. Authorization protocols exist. MCP connections exist. The infrastructure for autonomous agent purchasing is live on multiple platforms. The question isn't "will agents be able to buy things?" — they already can. The question is whether they'll be able to buy your things.

Your Second Customer Is a Procurement Officer

Here's the mental shift that matters most: you now have two customers. The human who sets the brief and approves the outcome. And the AI agent that executes the research, comparison, and purchase.

The agent isn't browsing your beautifully merchandised category page. It's not getting distracted by a lifestyle hero shot. It's not adding items to cart because of a clever upsell modal. It's parsing structured data in milliseconds — price, availability, specs, reviews, shipping cost, delivery time — and making a deterministic selection based on the user's stated constraints.

Optimizing for an AI shopping agent is like optimizing for a very fast, very literal procurement officer. One that evaluates dozens of options in seconds, has zero brand loyalty, and will skip any product where the data is ambiguous, incomplete, or requires interpretation.

What agents care about:

• Exact pricing — not "starting at $X" or "add to cart to see price." The agent needs the number.
• Real availability — not "usually ships in 2–4 weeks." Is it in stock right now? Can it deliver by Thursday?
• Complete specs — every attribute the user's brief might reference. Waterproof rating. Battery life. Material composition. Weight. Dimensions. If the agent can't confirm a spec from your data, it moves on.
• Shipping cost and speed — free shipping thresholds, express options, regional availability. Agents optimize for total cost, not just product price.
• Review signals — aggregate ratings, review count, recent review sentiment. Agents use these as quality proxies.

What agents don't care about:

• Your brand story video
• Your curated collection page layout
• Your "as seen in" press logos
• Your Instagram-worthy product photography (beyond what's needed to confirm the item matches the brief)
• Your emotional copywriting

This doesn't mean brand is dead. It means brand operates at a different layer — the human still approves or rejects the agent's recommendation, and brand familiarity influences that approval. But the agent is the gatekeeper. If you don't get past the agent, the human never sees you at all.

Product Feed Optimization for AI Agents

This is where the actionable work lives. Your product feed — the structured data that describes every item you sell — is now your most important marketing asset. Not your ad creative. Not your landing page UX. Your feed.

I've spent years optimizing Google Shopping feeds for ROAS. The discipline is similar but the requirements are stricter. Google Shopping tolerates some messiness — missing attributes get lower priority but still surface. AI agents are less forgiving. If your feed has gaps, the agent doesn't deprioritize you. It skips you, because it can't confirm you meet the user's constraints.

Structured Data: The Minimum Viable Agent-Readable PDP

Every product page needs JSON-LD schema markup that an agent can parse without ambiguity. Here's what a complete Product schema looks like — this is real, working markup, not pseudocode:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "TrailRunner Pro Waterproof Jacket",
  "description": "3-layer waterproof shell with 20,000mm hydrostatic head rating. Sealed seams, adjustable hood, two zippered pockets. Weight: 420g. Available in sizes XS–XXL.",
  "sku": "TR-PRO-WJ-001",
  "brand": { "@type": "Brand", "name": "TrailRunner" },
  "image": "https://store.example.com/images/tr-pro-wj-001.jpg",
  "offers": {
    "@type": "Offer",
    "url": "https://store.example.com/trailrunner-pro-waterproof-jacket",
    "priceCurrency": "USD",
    "price": "129.00",
    "priceValidUntil": "2026-12-31",
    "availability": "https://schema.org/InStock",
    "shippingDetails": {
      "@type": "OfferShippingDetails",
      "shippingRate": { "@type": "MonetaryAmount", "value": "0.00", "currency": "USD" },
      "deliveryTime": {
        "@type": "ShippingDeliveryTime",
        "handlingTime": { "@type": "QuantitativeValue", "minValue": 1, "maxValue": 2, "unitCode": "DAY" },
        "transitTime": { "@type": "QuantitativeValue", "minValue": 3, "maxValue": 5, "unitCode": "DAY" }
      },
      "shippingDestination": { "@type": "DefinedRegion", "addressCountry": "US" }
    }
  },
  "aggregateRating": { "@type": "AggregateRating", "ratingValue": "4.7", "reviewCount": "342" },
  "additionalProperty": [
    { "@type": "PropertyValue", "name": "Waterproof Rating", "value": "20,000mm hydrostatic head" },
    { "@type": "PropertyValue", "name": "Weight", "value": "420g" },
    { "@type": "PropertyValue", "name": "Material", "value": "3-layer nylon ripstop with DWR coating" }
  ]
}

Key things to notice:

• Price is explicit — no ranges, no "from," no hidden fees. The agent needs the exact number.
• Availability is schema-enum — InStock, OutOfStock, PreOrder. Not a text string like "usually ships soon."
• Shipping details are structured — cost, handling time, transit time, destination. This lets the agent calculate total delivered cost and delivery date, which humans often skip but agents optimize on.
• additionalProperty — this is where you put the specs that match common user briefs. Waterproof rating, weight, material — the attributes an agent will filter on.
• aggregateRating — review signals that agents use as quality proxies.

If your current PDPs have schema but it's minimal — just name, price, image — you're not agent-ready. The agent can confirm you exist but can't confirm you meet the brief. That's a partial visibility problem that's almost as bad as no visibility.

Feed Format: API-Accessible and MCP-Compatible

Structured data on the PDP is necessary but not sufficient. Agents also need to discover your catalog before they visit individual pages. That means your product data needs to be accessible as a feed — clean JSON or XML, ideally via an API endpoint an agent can query through MCP.

MCP (Model Context Protocol) is how agents connect to external tools and data sources. When an agent needs to search for waterproof jackets under $150, it queries connected product catalogs through MCP-compatible endpoints. If your store exposes an MCP server that returns structured product data, the agent can find you directly. If you rely only on web scraping and schema markup, you're dependent on the agent's web search step — which is slower, less reliable, and more likely to miss you.

Think of it like Google Shopping feed inclusion vs. organic search discovery. The feed is the guaranteed path. Schema on the PDP is the fallback. You want both.

For most D2C brands on Shopify or similar platforms, the practical path is:

• Ensure your Google Shopping / Merchant Center feed is complete and accurate — this is the feed infrastructure you already have
• Add comprehensive JSON-LD schema to every PDP — this is the web-discovery fallback
• Monitor MCP server tooling as it matures — when Shopify or your platform offers an MCP integration, adopt it immediately
• If you have custom infrastructure, build a lightweight product API that returns JSON matching schema.org Product structure — this is the direct-query path

The Product Feed Audit Checklist

Here's what to check and fix today. Not next quarter. Today — because the brands that are feed-ready by Q3 2026 will be the ones that capture the first real agent-driven shopping season, and the ones that aren't will simply not appear.

(The Q3 2026 timeline comes from shopappy.com's analysis — it's a prediction, not confirmed data. But the logic is sound: platforms are pushing agent-readable feed adoption ahead of holiday 2026, and brands that wait will miss the window.)

1. Schema completeness — Run every PDP through Google's Rich Results Test or schema.org validator. Flag any page missing: name, price, priceCurrency, availability, image, sku, brand, description. Fix them.
2. Spec coverage — For your top 50 products by revenue, list every attribute a user might include in a purchase brief (size, weight, material, waterproof rating, battery life, compatibility, etc.). Check whether each attribute exists in your schema additionalProperty or in your feed. Fill the gaps.
3. Pricing transparency — Find every product where the displayed price doesn't match the purchasable price (add-to-cart reveals, variable shipping not shown, bundle-only pricing). Make the total delivered cost explicit in schema.
4. Availability accuracy — If your schema says InStock but your inventory system says 3 units left with 2-week restock, that's a mismatch that will burn agent trust fast. Connect schema availability to real inventory data.
5. Shipping details — Add OfferShippingDetails to schema for every product. Free shipping threshold, express cost, regional restrictions, handling + transit time estimates. Agents optimize for total cost and delivery speed — this data directly influences whether you beat competitors.
6. Review signals — If you have reviews but no aggregateRating in schema, add it. If your aggregateRating is stale (not updated in 30+ days), connect it to a live feed from your review platform.
7. Feed-to-PDP consistency — Your Google Shopping feed and your PDP schema should tell the same story. Same price. Same availability. Same specs. Inconsistency between feed and page is a trust signal for agents — and a negative one.
8. API accessibility — If you have a product API, document it. If you don't, plan one. The minimum viable version: a GET endpoint that returns your top 200 products as JSON matching schema.org Product structure, filterable by category and key attributes.

Most brands I've worked with have maybe 40% of this in place. The schema exists but is thin. The feed exists but has gaps. Shipping details are nowhere. Specs are in bullet-point text on the PDP but not in structured data. That's the starting point — not a disaster, but not agent-ready either.

Agent SEO — Being the Product an AI Recommends

Traditional SEO optimizes for human searchers typing queries into Google. Agent SEO optimizes for AI agents querying product catalogs on behalf of humans with specific purchase briefs.

The discipline is different in three ways:

1. Agents don't scroll. A human might scan page one of Google results and click result #4. An agent evaluates every matching product it can access and returns a short list of 2–3. There's no "below the fold" for agents — but there's also no second chance. If you're not in the top 2–3 for a given brief, you're not in the outcome at all.

2. Agents match on attributes, not keywords. A human searches "waterproof jacket." An agent receives the brief "waterproof jacket under $150, best-reviewed, delivers by Friday." The matching logic is attribute-level: does the waterproof rating meet the implied standard? Is the price ≤ $150? Is the aggregate rating high enough? Is delivery feasible by Friday? Keyword optimization doesn't help here — attribute completeness does.

3. The product page is the new homepage. When an agent evaluates your product, it reads the PDP directly. It doesn't navigate from your homepage through category pages to the product. The PDP is the entry point, the evaluation surface, and the decision point — all in one. This is why PDP schema completeness matters more than site architecture or internal linking for agent discoverability.

Agent SEO isn't a replacement for traditional SEO — it's an additional layer. You still need to rank in Google for human searchers. You still need AI search visibility for ChatGPT and Perplexity recommendations. But agent SEO adds a third dimension: being parseable, complete, and trustworthy enough that an agent executing a purchase brief selects you over competitors with equivalent products but weaker data.

The competitive dynamic here is brutal. In traditional search, position #4 still gets traffic. In agent commerce, position #4 doesn't exist. The agent returns 2–3 options. If three competitors have cleaner feeds, more complete specs, and more transparent pricing than you, you're out — even if your product is objectively better.

How Agents Discover Products

Agents don't discover products the way humans do. They don't see your Instagram ad. They don't open your email campaign. They don't browse your New Arrivals page. They discover products through three paths:

Path 1: MCP-connected catalog queries. The agent queries a product catalog through an MCP server. This is the fastest, most reliable path — the agent gets structured data directly, no web scraping, no parsing HTML. If your store exposes an MCP server with your catalog, agents connected to that server can find you deterministically. This is like being in the Google Shopping feed index — you're guaranteed to appear for matching queries.

Path 2: Platform shopping integrations. ChatGPT, Google, and other platforms are building shopping integrations that give agents access to curated product catalogs. Think of these as the agent-era equivalent of Amazon Marketplace or Google Shopping — platforms that aggregate product data and make it available to their agents. Being listed in these catalogs is critical. The exact mechanics are still evolving, but the direction is clear: platform-hosted product data is the primary discovery surface for agents.

Path 3: Web search + schema parsing. The agent searches the web, finds your PDP, and parses the JSON-LD schema. This is the fallback path — slower, less reliable, dependent on the agent's ability to find your page through search and extract clean data from it. It works, but it's not the preferred path for the agent, and it's not the path you should rely on.

The strategic priority is clear: get into Path 1 and Path 2 as early as possible. Path 3 is your safety net.

For Path 1, watch MCP server tooling from your platform provider. Shopify, BigCommerce, and others will likely offer MCP integrations — when they do, adopt immediately. If you're on custom infrastructure, building a basic MCP server for your product catalog is a weekend project with substantial long-term payoff.

For Path 2, monitor how each platform opens its shopping catalog to merchants. The process will likely parallel Google Merchant Center enrollment — feed submission, verification, quality checks. Get your feed clean now so you're ready to submit when the doors open.

For Path 3, the schema audit I described above is the work. Make every PDP parseable. Make the data complete. Make it consistent with your feed.

What to Do Now vs. What to Wait On

Some of this infrastructure is live. Some is coming. Here's how I'd prioritize:

Do Now (July–September 2026)

• Complete the PDP schema audit — This is zero-dependency work. You own your pages. You can add JSON-LD today. Start with your top 50 products by revenue and work outward.
• Fix pricing transparency — Eliminate every "add to cart to see price" and every hidden shipping cost. This helps human customers too, but it's mandatory for agents.
• Connect availability to real inventory — If your schema says InStock, it should mean InStock right now, not "we might have some in the warehouse."
• Add shipping details to schema — OfferShippingDetails is underused by most brands. Add it. The total-cost and delivery-date calculations agents make depend on this data.
• Clean your Google Shopping feed — The feed hygiene you need for Google Shopping is 80% of what you need for agent commerce. Close the gaps now and you're ahead of most competitors.
• Document your product attributes — Create a master list of every spec, feature, and attribute that appears in customer purchase briefs for your category. Map each attribute to where it lives in your feed and schema. Fill the gaps.

Prepare (Q3–Q4 2026)

• Build a product API endpoint — Lightweight JSON API returning schema.org Product structures for your catalog. This is the foundation for MCP server integration and direct agent queries.
• Monitor MCP server releases from your platform — When Shopify or your platform ships an MCP integration, you want to be in the first wave of adopters.
• Watch for platform shopping catalog enrollment — Each agent platform (ChatGPT, Google, others) will open merchant enrollment at some point. Have your feed ready so you can submit immediately.
• Test agent readability — Use ChatGPT or other agents to simulate purchase briefs in your category. See what products surface. See if yours appear. See what data the agent pulls. This is cheap, fast reconnaissance.

Wait (But Don't Ignore)

• Dedicated agent advertising — Paid visibility on AI platforms (ChatGPT ads, Perplexity sponsored results) is emerging but not fully structured for commerce yet. Monitor it, but your primary investment should be in feed and schema work first. (We cover this in depth in our post on ChatGPT advertising and paid visibility on AI platforms.)
• Autonomous campaign management — AI marketing agents that manage your ad campaigns autonomously are coming, and they connect to this ecosystem through MCP and similar protocols. But the infrastructure isn't stable enough for production use yet. (Our Meta Ads MCP post covers where this stands today — I'm not trusting it with live spend yet.)
• ACP/AP2 deep integration — The commerce and payment protocols are live but evolving. Don't build custom integrations against them until the specs stabilize. Use platform-provided integrations instead.

The pattern here mirrors what I've seen in every platform shift: the brands that clean up their data infrastructure early win the first wave, and the brands that wait for "everything to be stable" arrive two years late to a market that's already consolidated around the early movers. Google Shopping in 2012 was the same dynamic. The brands with clean feeds captured the first ROAS advantage. The ones that waited spent 18 months catching up.

The Risks Nobody Is Talking About

Most coverage of agentic commerce focuses on the opportunity. Here's what I'm worried about:

Agent Bias Toward Platform-Owned Products

When ChatGPT runs a shopping query, where does it look first? The catalogs it's directly connected to — which, over time, will favor marketplace products from the platform's own retail partners. This is the same dynamic that pushed brands off Amazon into D2C: the platform's own inventory gets priority placement. If you're selling on a platform's marketplace, you might get agent visibility. If you're purely D2C, you're relying on Path 3 (web search + schema) until you get into Path 2 (platform catalogs). That's a structural disadvantage.

Price Transparency Eroding Margin

Agents optimize for total delivered cost. They compare across every accessible option in seconds. This makes price comparison instant and exhaustive — not the clunky manual comparison humans do. If your margin depends on customers not finding the cheaper alternative, agentic commerce will strip that margin fast. The only defenses: differentiation that can't be reduced to spec comparison (design, exclusivity, service bundles), and attribute completeness that lets you compete on dimensions beyond price (delivery speed, warranty, review quality).

Commoditization When Agents Optimize on Specs Alone

If an agent receives the brief "waterproof jacket under $150, best-reviewed," and three products match those constraints with similar specs and ratings, the agent will likely pick the cheapest one or the one with the fastest delivery. Brand preference doesn't enter the logic unless the user explicitly names a brand in the brief. This means brands that compete on spec parity — similar products, similar prices — get commoditized. The agent treats them as interchangeable. Your brand story, your visual identity, your customer experience — none of it matters at the agent selection layer.

The counter-strategy: make your product uniquely matchable. Offer specs that competitors don't have. Bundle services that agents can parse as additional value. Structure your warranty, return policy, and post-purchase support as schema properties that appear in the agent's evaluation. If the agent sees "90-day no-questions return + free repair service" as a structured attribute on your product but not on competitors, that's a differentiator it can actually weigh.

The "Second Customer" Changes CRO Forever

Conversion rate optimization has always targeted the human — reducing friction, building trust, creating urgency. Now you're optimizing for two audiences simultaneously: the agent (structured data completeness, attribute clarity, feed consistency) and the human (brand trust, visual appeal, emotional resonance). These aren't always aligned. The agent wants every spec listed in schema. The human wants a clean, scannable product page. The agent wants explicit pricing including shipping. The human might respond better to "free shipping over $75" as a motivational callout.

You have to serve both. The schema serves the agent. The page design serves the human. They coexist on the same PDP. The schema is invisible to the human but determinative for the agent. Get this wrong — prioritize human UX at the expense of schema completeness — and you lose the agent gatekeeper. Prioritize schema at the expense of human experience — and the human rejects the agent's recommendation when they finally see your page.

This Is a Data Problem, Not a Marketing Problem

The hardest part of agentic commerce preparation isn't the marketing strategy. It's the data engineering. Making your product feed complete, consistent, and real-time-connected to inventory and pricing systems is infrastructure work. It's the same kind of plumbing I've built for ad reporting pipelines — pulling from multiple sources, normalizing, validating, keeping it fresh.

When I migrated reporting from manual spreadsheet exports to a real-time dashboard pulling from five ad platforms via API, normalized in Python, visualized in Looker Studio, the hardest part wasn't the visualization. It was getting clean, consistent data out of five different platforms with five different data schemas. Product feed optimization is the same challenge: your ERP, your PIM, your Shopify store, your Google Shopping feed, and your PDP schema all need to tell the same story in the same format.

Most marketing teams can't do this alone. You need data engineering support — either in-house or through your platform. Start the conversation now. The brands that treat this as "just another SEO task" will underinvest. The brands that recognize it as an infrastructure project will get it right.

Where This Connects to Your Broader AI Strategy

Agentic commerce isn't an isolated trend. It connects to three other shifts happening simultaneously:

• AI search visibility — ChatGPT, Perplexity, and Gemini are already recommending products in conversational answers. Agent SEO for recommendations and agent SEO for purchases share the same foundation: structured data, complete attributes, feed cleanliness. Invest in one and you're investing in both.
• AI advertising on agent platforms — When ChatGPT runs a shopping query, paid placement will follow. The brands that are discoverable organically (through feeds and schema) will have a baseline. The brands that also buy paid visibility will dominate. (Our post on ChatGPT advertising covers where this market stands.)
• Autonomous campaign management — AI marketing agents managing your ad spend will eventually connect to agent commerce through MCP and similar protocols. Your agent-optimized feed becomes the input for your agent-managed campaigns. The same product data that makes you purchasable also makes you advertisable. (The Meta Advantage+ analysis and MCP setup post cover where autonomous campaign management is production-ready and where it isn't.)

The stack is converging. Feed optimization → agent discoverability → agent purchasability → agent advertising → agent campaign management. It's one pipeline. Start at the foundation.

The Window Is Open But It Won't Stay Open Forever

Every platform shift has an early window where clean-data brands capture disproportionate visibility. Google Shopping in 2012. Amazon Marketplace in 2015. Instagram Shopping in 2020. The brands that moved first got the best positions, the lowest CPAs, and the strongest organic footholds. The brands that waited spent years and millions catching up.

Agentic commerce is that shift right now. The payment infrastructure is live. The protocols are maturing. The agents are starting to shop. But the catalog surfaces — the MCP connections, the platform shopping integrations — are still forming. That means the brands with complete feeds and clean schema will be first in line when the catalogs open. The brands with messy data will be queued behind them.

Run the audit. Fix the schema. Clean the feed. Build the API. You don't need to bet the company on agentic commerce — you need to bet a weekend and a data engineer on making your product data agent-readable. That's the minimum viable investment, and it's the one that will compound fastest as this infrastructure matures.

The agent doesn't care about your brand story. It cares about your data. Make sure your data is worth recommending.

Frequently Asked Questions

• What is agentic commerce and how does it differ from conversational commerce?

  Conversational commerce is an AI recommending a product and the human clicking through to buy it. Agentic commerce is the AI executing the entire purchase loop — research, comparison, selection, payment — on behalf of the user. The key difference: in conversational commerce, the human is the purchaser. In agentic commerce, the agent is the purchaser, acting under delegated authority from the human.

• How do AI shopping agents actually discover and evaluate products?

  Agents discover products through three paths: MCP-connected catalog queries (direct, structured, fastest), platform shopping integrations (curated catalogs like the agent-era equivalent of Google Shopping), and web search plus schema parsing (fallback, slower). Once discovered, agents evaluate products by parsing structured data — price, availability, specs, shipping details, review signals — in milliseconds. They match products against the user's stated constraints and return a short list of 2–3 options, not a scrollable page of 50 results.

• What structured data does an AI shopping agent need on a product page?

  Complete JSON-LD schema.org Product markup including: name, description, sku, brand, image, price (exact, not a range), priceCurrency, availability (as schema enum: InStock/OutOfStock/PreOrder), shippingDetails (cost, handling time, transit time, destination), aggregateRating (ratingValue and reviewCount), and additionalProperty for every spec attribute a user brief might reference (waterproof rating, weight, material, battery life, etc.). Thin schema — just name, price, image — isn't enough. The agent can confirm you exist but can't confirm you meet the brief.

• What is agent SEO and how is it different from traditional SEO?

  Agent SEO optimizes for AI agents executing purchase briefs, not humans typing search queries. Three key differences: agents don't scroll (they return 2–3 options, so position #4 doesn't exist), agents match on attributes not keywords (they filter by specs, price, delivery, ratings), and the product page is the entry point (agents read PDPs directly, not navigate from homepages). The foundation is the same — structured data, complete feeds — but the competitive dynamic is stricter: if three competitors have cleaner data, you're excluded from the outcome entirely.

• What risks do brands face when agents optimize purely on price and specs?

  Three major risks: agent bias toward platform-owned marketplace products (D2C brands rely on fallback discovery paths until platform catalogs open), price transparency eroding margin (agents compare every accessible option instantly and exhaustively), and commoditization when agents treat spec-parity products as interchangeable (brand story and visual identity don't enter agent selection logic unless the user names a brand in the brief). Counter-strategies: make products uniquely matchable with specs competitors don't offer, bundle parseable service value (warranty, returns, support), and structure differentiators as schema properties agents can weigh.

• How should brands prepare for holiday 2026 agentic shopping?

  Run a PDP schema audit on your top 50 products by revenue — fix every page missing price, availability, shipping details, or key specs. Eliminate pricing opacity (no 'add to cart to see price'). Connect schema availability to real inventory data. Add OfferShippingDetails to every product. Clean your Google Shopping feed (the hygiene you need there is 80% of what you need for agents). Build a lightweight product API returning schema.org Product JSON. Then monitor MCP server releases from your platform and platform shopping catalog enrollment — when doors open, you want your feed ready to submit immediately.

Related reading: SEO Isn't Dead: How to Rank in the Age of AI Search in 2026

Related reading: Google Performance Max: How to Actually Control the AI Black Box

References

• Agentic Commerce: Architect Your Catalog for AI Agents
• Agentic Commerce: When AI Agents Shop for Your Customers
• What Is Agentic Commerce? AI Shopping Agents Explained (2026)
• Agentic Commerce: How AI Shopping Agents Buy in 2026
• Agentic commerce: feeds, not payments, gate holiday 2026
• Agentic PDP: What a Product Page Needs for Bots