Product catalog for AI agents: Lessons from Ulta and Sompo

product catalog for AI agents matters when an assistant must recommend, compare, and buy on a user’s behalf. Ulta built a shopping assistant that navigates roughly 30,000 SKUs to answer intent like, "a vitamin C serum under $50 for sensitive skin," while Sompo deployed over 10,000 custom AI agents to automate document and internal knowledge tasks for 34,000 employees. These two programs show that scale, structure, and reachability decide whether an AI assistant can find and act on your products, not marketing prose or image galleries (Ulta and Sompo case study).

If you want agents to surface your items in multi-turn shopping flows, treat your catalog as a developer data product. That means clear attributes, consistent identifiers, machine-readable schema, and APIs that expose up-to-the-minute availability and price. The steps below convert human-friendly pages into an asset AI agents can query, compare, and use to complete purchases.

Key takeaways

• Implement Schema.org Product and Offer JSON-LD on every product page so agents can parse attributes like price, availability, and brand.
• Provide consistent unique identifiers, GTIN or SKU, and normalized taxonomy to avoid duplicate or mismatched listings across feeds.
• Expose a Catalog API or feed with near real time updates and cart endpoints so agents can complete multi-turn checkout flows.
• Design conversational metadata: short intent phrases, one-sentence use cases, and alternative suggestions for comparison and substitutions.
• Monitor catalog freshness, guardrails, and test agents end to end to keep recommendations accurate and compliant at scale.

How do I structure a product catalog for AI agents?

Answer: Structure a catalog as machine-readable records, not as marketing pages. Use a per-SKU JSON record with standardized fields, a canonical identifier, a minimal human summary, and a clear mapping to images and variants.

Start with a canonical source of truth for every SKU. Each record should include a stable identifier such as GTIN or your internal SKU, a parent product id for variants, brand, title, category, and a short 1-2 sentence description optimized for intent queries. Store structured attributes as typed fields, for example: price.currency, price.amount, availability.status, dimensions.unit, color.name. Avoid embedding important attributes inside long HTML paragraphs or promotional copy that an agent cannot reliably parse.

Publish every product as Schema.org JSON-LD Product and Offer markup so web crawlers and agents can parse core attributes directly from pages. Schema.org JSON-LD remains the baseline for machine readability, and implementing Product, Offer, and MerchantReturnPolicy helps agents decide on recommendation and purchase logic (schema guidance). Store a machine catalog as a separate data layer that mirrors your public site but exposes normalized fields, category ids, and vector embeddings for semantic search.

Concrete record structure

1. id: canonical SKU or GTIN string.
2. title: short descriptive title, 60 characters or less.
3. brand: normalized brand id.
4. category_id: mapped to an industry taxonomy.
5. price: {amount, currency, list_price, sale_price}.
6. availability: {in_stock:true/false, ship_from, lead_time_days}.
7. attributes: key value pairs for size, color, ingredients, technical specs.
8. images: prioritized URLs with alt text and type (hero, swatch, step).
9. short_intent: 8 to 15 words users use when asking an assistant.
10. guardrails: boolean flags for restricted sale, adult content, or special handling.

Tradeoffs: store-level catalogs prioritize fidelity to site layout but require substantial normalization for cross-store comparison. Centralized normalized catalogs speed agent discovery and comparison, but they require mapping pipelines and reconciliation, like the catalog clustering problems Shopify solved at scale (Shopify clustering). If you cannot launch a full normalized layer at once, start by publishing high-quality JSON-LD plus a feed or API that mirrors your canonical SKU records.

What metadata does a product catalog for AI agents need?

Answer: Agents need identity, commerce, and conversational metadata. At minimum, include unique identifiers, price and availability, rich attribute sets, images, reviews, and short intent lines for conversations.

Identity metadata keeps matching precise. Provide GTIN, manufacturer part number, and your internal SKU. If GTIN is not available, use a stable composite id and document why it is unique. Commerce metadata must include current price, list price, promotions with start and end timestamps, stock level or boolean availability, shipping options, and return policy. Agents use these fields when deciding whether to recommend or place an order.

Attribute metadata powers comparisons. For apparel this includes size charts, material, fit notes, and care instructions. For beauty, include skin type suitability, active ingredients, and concentration percentages. For technical goods, provide key specs in structured fields so agents can match user constraints. Include normalized taxonomy tags mapped to a standard like Google product categories or your own unified taxonomy. Use consistent names across channels so matching inside the agent context becomes deterministic.

Conversational metadata and trust signals

Add short intent phrases and one-line use cases, such as "suitable for oily skin" or "for 5k runners under 8 minutes per mile." Provide review aggregates, number of ratings, and verified purchaser badges. Flag restricted items and provide policy text that agents can quote. These trust signals and small intent phrases improve the quality of multi-turn recommendations and reduce back-and-forth clarification.

Mapping and normalization steps

1. Audit fields across feeds and remove synonyms, for example, unify "colour" and "color" to a single attribute.
2. Map categories to one canonical taxonomy and store category ids alongside human labels.
3. Backfill missing GTINs, or document fallback id rules.
4. Run quality checks weekly to find missing price or availability fields that break agent flows.

APIs and feeds: How should I expose my product catalog so AI agents can call it?

Answer: Publish a queryable Catalog API plus event-driven feeds for real time inventory and price updates. Allow read endpoints for product details, search, recommendations, and cart operations so agents can complete multi-turn flows.

Design the API with a clear contract. Provide GET /products/{id} to return the full machine record, POST /search or GET /search with filters and semantic search parameters, and POST /cart and PUT /cart/{id} to enable add to cart. Agents will expect item-level availability and a short latency for inventory checks prior to checkout. Push price and stock changes through a webhook or streaming feed so agents never read stale data during a conversation.

Support both structured and semantic queries. Provide facet filters for price range, brand, and category, and a semantic similarity endpoint that accepts an intent phrase and returns ranked SKU ids with relevance scores and short reasoning. If you expose embeddings or a vector search endpoint, agents can surface alternatives and substitutes that match user intent even when titles differ.

Adopt an industry standard where possible. Ulta worked with Google around a Universal Commerce Protocol for agentic commerce to make product discovery and transactions work inside Gemini and AI Mode in Search (UCP mention). Whether you implement UCP or your own schema, document endpoints, rate limits, and the freshness SLA so third-party agents can integrate reliably.

Practical API implementation checklist

• Expose product read, search, and cart endpoints, with schema documentation and examples.
• Provide webhooks or streams for price and inventory change events and a change log endpoint for delta updates.
• Return reasoning fields or provenance tags that say where price and availability came from.
• Offer a sandbox with sample data and test tokens so agents can run multi-turn flows end to end.

Designing catalogs for multi-turn shopping flows and personalization

Answer: Design product records and APIs to support stateful conversations, easy substitutions, and personalization by storing intent signals and customer context alongside product data.

For multi-turn flows, agents need to ask clarifying questions rarely. Supply short_intent labels, suggestion sets, and substitution rules in the product record. For example, include recommended alternatives with reasons such as "lower price," "fragrance free," or "more suitable for dry skin." That lets an agent answer a follow-up like, "Show cheaper options that still work for sensitive skin," without calling multiple endpoints and re-parsing long descriptions.

Surface personalization inputs early. If you have loyalty or purchase history data, make it available to the agent as part of the context when authorized by the user. Ulta moves purchase and loyalty signals into conversation context to improve precision, using first-party data to defend differentiation when outside agents mediate purchases (Ulta loyalty and context). Store personalization keys in the catalog or a linked profile service and document how the agent can fetch consented data during a session.

Support transactional hooks. A product record should indicate whether an item can be fulfilled via pickup, delivery, or third-party marketplace, and include a fulfillment_id to trigger the right checkout path. Provide clear error states for out of stock, price mismatch, or restricted sale, and return user-friendly messages the agent can present without rewording policy legalese.

Testing conversational flows

Run synthetic conversations against a sandbox catalog and measure completion rate, clarification rate, and time to add to cart. Test edge cases like simultaneous price changes during a session, variant selection failures, and fallback when the recommended SKU is not available. These metrics reveal whether your catalog and APIs support reliable multi-turn commerce.

Operational practices for catalog freshness, governance, and testing

Answer: Maintain freshness, automate quality checks, and enforce guardrails. At scale, agents break when products are stale or when policy flags are missing.

Schedule automated checks that validate core fields hourly for fast-moving SKUs and daily for slower categories. Verify price, availability, shipping, and return policy timestamps. Flag changes larger than a configured threshold and require human review for changes that affect policy or restricted items. Keep provenance metadata for price and availability so you can audit recommendations later.

Implement a governance layer with roles, approvals, and a change history. Ensure marketing copy changes do not overwrite critical structured attributes. Separate the machine catalog from marketing content so an editor can update the page without breaking agent-facing fields. Use CI pipelines for catalog changes and run unit tests against sample agent queries to ensure the result set remains stable after updates.

Operational scale matters. Sompo reduced development time for models dramatically by standardizing agent development and reusing tooling across 10,000 agents, which required solid governance and automation (Sompo case). If you expect many agent integrations, invest early in monitoring, reasoned error messages, and a rollback plan for catalog changes that degrade recommendation quality.

Monitoring and KPIs

• Freshness SLA compliance for price and inventory, measured hourly.
• Agent recommendation accuracy, measured by click through and add to cart conversion.
• Clarification rate in conversations, aiming to reduce unnecessary follow-ups.
• Policy violation incidents, tracked monthly and tied to remediation tickets.

FAQ

How do I make my product catalog discoverable to AI shopping agents?

Make your catalog machine-readable with Schema.org JSON-LD, publish a documented Catalog API, and provide feeds or webhooks for price and inventory changes. Provide unique identifiers like GTIN or SKU and a normalized category mapping so agents can match items reliably.

What are the minimum metadata fields an AI agent needs to recommend a product?

At minimum include canonical id, title, price, currency, availability, brand, category id, images, and a short intent or use case string. Reviews count and rating help ranking, and a return policy field improves decision quality.

Do I need to expose embeddings or vector search for agents to work?

No, you can start with strong structured fields and semantic labels plus a search endpoint. Embeddings and vector search improve recall and substitution quality, but they are incremental. Start with JSON-LD and a catalog API, then add embeddings if you need better semantic matching.

How often should I update my catalog for AI agent use?

Update inventory and price changes in near real time for fast-moving retail items, at least hourly. Less volatile attributes, like specifications, can be validated daily. Document freshness SLAs so agents know when to recheck before checkout.

What governance controls prevent agents from recommending restricted products?

Use guardrail flags in product records, policy categories, and an automated policy check in the API layer. Block recommendations when a product has a restricted flag or requires additional verification, and provide human review flows for exceptions.

Next step: run a quick audit of your top 1,000 SKUs and ensure each has a canonical id, JSON-LD Product markup, price and availability timestamps, and a short intent phrase. If you need an automated catalog readiness score or continuous monitoring for agent visibility, idou.ai can help measure how often AI assistants mention and recommend your brand compared to competitors.

Related reading: see our 90-day GEO playbook for local businesses at /blog/90-day-geo-playbook-local-sprint, and the guide on tracking brand presence across AI assistants at /blog/track-brand-presence-ai-assistants.