Agentic Commerce Product Feeds

A classic shopping surface shows a ranked grid: dozens of products, each with a thumbnail and a price, and the shopper does the filtering. An AI agent inverts that. It receives an intent (“waterproof trail shoes under $120 that ship this week”), resolves it against indexed product data, and returns one short answer with a small set of candidates. There is no page two. If your product data cannot answer the agent’s constraints — availability, delivery window, return policy, sizing — the product is not down-ranked, it is simply absent from the answer. That shifts feed work from “optimise titles for a keyword auction” toward “expose every decision-relevant attribute in a machine-readable field”, because the agent, not the shopper, is now the one reading your catalog.

Under both ACP and UCP the agent does more than recommend: it can build a cart, initiate checkout, and pass payment through a tokenised flow while the merchant remains the merchant of record. Google’s own framing example is an instruction like “order the same coffee I bought last month if the price hasn’t gone up more than 10%” — consented, condition-bound, autonomous purchasing. For product data this means correctness stops being a quality score and becomes a contract: a stale price or phantom stock level in a classic channel costs a click; in an agentic checkout it breaks a transaction the shopper never saw, along with the agent’s willingness to recommend that seller again.

As of mid-2026 the spec defines 79 fields, of which 18 are required. The required core will look familiar from Google Shopping: item_id, title, description, url, brand, image_url, price (number plus ISO currency, e.g. 79.99 USD), and an availability enum. What is new is the required seller context: seller_name, seller_url, and a return_policy URL are mandatory for every product, and enabling checkout additionally requires seller_privacy_policy and seller_tos URLs. Geo targeting is also required — target_countries and store_country — because the agent must know where an offer is actually valid before recommending it.

The optional tiers are where agentic ranking is won. The spec reserves structured slots for evidence a conversational agent can quote directly: review_count and star_rating (plus store-level equivalents), a q_and_a list of question-answer pairs, full reviews objects, popularity_score, return_rate, and a pricing_trend string such as “Lowest price in 6 months”. Variants use group_id plus a variant_dict map of option names to values, mirroring item-group logic from classic feeds. A useful mental model: every field you populate is a sentence the agent is allowed to say about your product; every field you leave empty is an answer it has to hedge or skip.

OpenAI’s recommended operating model is a daily full-feed upload plus intraday delta updates through the API, with the fastest documented refresh at fifteen-minute intervals. That cadence exists because agentic checkout collapses the distance between “data in feed” and “money moving”: price and availability drift that a weekly re-crawl would eventually fix on a classic channel becomes a failed or mispriced transaction in ChatGPT. Practically, that means your feed pipeline needs the same discipline as your order pipeline — regeneration triggered by catalog change events, not by a nightly cron alone, and monitoring that alerts when the delta stream stalls.

Both protocols are open standards, both keep the merchant as merchant of record, and both ultimately resolve against structured product data. They differ in scope and ingestion: ACP pairs a ChatGPT-specific product feed (OpenAI’s 79-field schema, uploaded to OpenAI) with a checkout specification, while UCP defines journey-wide primitives and inherits its catalog from Merchant Center rather than defining a brand-new feed format. Strategically they are not competitors you choose between — they are two doors to two different agent populations, and the shopper decides which agent they ask. Merchants who treat them as one requirement (“expose a clean, complete, fresh catalog to agents”) rather than two projects end up maintaining one pipeline with two thin output mappings.

The sustainable architecture is the one feed managers already know: one canonical catalog, per-channel transformations at export time. ACP’s required fields map almost one-to-one onto a well-maintained Google Shopping feed — item_id/id, image_url/image_link, price-with-currency formats match — and the genuinely new fields (seller URLs, policy links, eligibility flags) are store-level constants, not per-product authoring work. The trap to avoid is forking the catalog: a separate hand-maintained “AI feed” drifts from the real one within weeks, and drift is precisely what agentic checkout punishes. Generate every protocol output from the same validated source, and let the mapping layer — not humans — absorb spec changes.

If you already export a healthy Google Shopping feed, roughly the whole required core of the OpenAI spec is a renaming exercise: identifiers, titles, descriptions, URLs, brand, images, price formats, and availability enums all carry over with minor transforms (for example in stock becomes in_stock). The genuinely new work concentrates in three places: store-level policy fields (seller name/URL, return policy, privacy policy, terms — one-time additions), the eligibility flags (a per-product business decision about what may be searched and what may be bought in-agent), and the delta pipeline (event-driven updates rather than nightly regeneration). Audit in that order; it front-loads the cheap wins.

Every protocol ingest is a validation gate, and agentic gates are stricter versions of the ones feed managers already fight: length limits, enum vocabularies, URL resolvability, identifier checksums. The failure economics are familiar from Meta’s row-level validation — one malformed field can drop a product from the surface entirely, silently. The defence is the same as ever, applied earlier: validate at export time against each destination’s rules, catch the offending field while it is still a preview warning rather than a dropped row, and keep validation rules versioned so a spec change becomes a rule update, not a production incident. A catalog that already passes strict per-field validation is, in practice, most of the way to agent-ready.

Two developments are worth tracking. First, convergence pressure: Stripe sits in both camps, UCP declares compatibility with the payment- and agent-protocols around it, and merchants are already asking the ecosystem for one mapping instead of two — expect the specs to keep borrowing from each other. Second, the ads layer: the OpenAI feed spec already reserves is_eligible_ads and an ads_metadata object, which signals that paid placement inside agent answers is coming to ChatGPT surfaces. When it arrives, the merchants with complete, trusted feeds will be bidding on inventory the rest cannot enter — the same early-mover dynamic Google Shopping rewarded a decade ago, replayed at protocol speed.

Agentic surfaces are real but young: rollouts are market-by-market, specs are versioning quickly, and traffic from agent-mediated shopping is still small next to classic search for most catalogs. The rational posture for most merchants in 2026 is preparation over speculation: keep one validated catalog, add the store-level policy and trust fields once, wire the delta pipeline, and opt into each surface as it opens in your market. That converts agentic commerce from a re-platforming project into an incremental export target — and it means the day an agent surface matters in your category, your catalog is already speaking its language.