How to Make Your Products Discoverable by AI Agents
AI agents cannot recommend products they cannot reliably find or understand.
That sounds obvious, but most online stores were never designed for machine-directed shopping. They were built for people navigating menus, viewing images, opening variant selectors, and interpreting visual layouts.
AI agents interact with commerce differently.
A shopper might ask an agent to:
“Find a lightweight waterproof jacket under $120 that comes in navy and can arrive this week.”
To answer that request, the agent needs more than a page containing the words “waterproof jacket.” It needs to identify the product, understand its attributes, compare its offers, verify that the requested variant exists, and determine whether the information is current.
This means product visibility for AI agents depends on four things:
- Accessibility
- Structure
- Freshness
- Trust
Here is how merchants can improve each one.
1. Give every product a stable canonical URL
Every product should have one permanent URL that represents its primary source of truth.
Avoid creating several URLs for the same product through tracking parameters, collection paths, regional navigation, or temporary campaign pages without identifying the canonical version.
For example, these URLs might all display the same item:
https://example.com/products/travel-backpack https://example.com/collections/bags/products/travel-backpack https://example.com/products/travel-backpack?campaign=summer
Agents and crawlers should not have to guess whether these are three products or three routes to the same product.
Use a canonical link element to identify the authoritative page, and keep that URL stable whenever possible.
A stable product identity makes it easier to:
- Merge observations from multiple crawls
- Prevent duplicate listings
- Track changes over time
- Preserve links and agent references
- Associate variants with the correct product
Changing a product URL should be treated as an identity migration, not a routine design adjustment.
2. Make essential product information available without interaction
A customer may be willing to click a size selector, open an accordion, wait for JavaScript, or scroll through an image carousel.
An automated crawler may not.
Important commerce data should be available in the initial page response whenever practical. This includes:
- Product name
- Description
- Brand
- Price
- Currency
- Availability
- Variant names
- Product images
- Merchant identity
- Purchase URL
Google can render JavaScript, but rendering happens as a separate stage of its crawling process. Other crawlers and agent systems may have different capabilities or stricter time limits. A product page should not depend entirely on browser interaction before its basic commercial meaning becomes available.
This does not mean your storefront must be visually simple. It means the underlying information should remain accessible beneath the interface.
3. Add accurate Product and Offer structured data
Structured data explicitly tells machines what each piece of information means.
A heading that displays $49.00 may look like a price to a person. JSON-LD can identify it as a price, associate it with USD, connect it to a particular offer, and state whether that offer is currently available.
Product pages should use Schema.org Product and Offer markup where appropriate.
Useful properties include:
namedescriptionimagebrandskugtinmpncategoryofferspricepriceCurrencyavailabilityurl
If a product has meaningful variants, represent the relationships among the parent product and its available options consistently.
Google’s merchant listing documentation also explains how Product and Offer data can communicate price, availability, shipping, and return information.
Structured data should match the visible product page. Publishing values that conflict with what customers see creates ambiguity rather than clarity.
4. Describe the product in the language customers use
Agents commonly begin with an intent, not a product name.
A customer may not ask for your exact title. They might ask for:
- “A tool that makes listing products easier”
- “A carry-on bag for a three-day business trip”
- “A necklace that will not irritate sensitive skin”
- “Software that turns product photos into Shopify listings”
A product description should therefore explain more than what the product is called.
It should clearly communicate:
- What the product does
- Who it is for
- Which problem it solves
- Its distinguishing materials or capabilities
- Important limitations
- Relevant compatibility
- Common use cases
Avoid filling descriptions with disconnected keywords. Agents benefit more from precise, natural language that establishes relationships among the product, its features, and the shopper’s likely needs.
A strong description helps both conventional search and semantic product discovery.
5. Represent variants as real offers
Color, size, material, capacity, condition, and subscription level can determine whether a product satisfies a request.
Do not reduce every variant into an unstructured sentence.
Each purchasable option should have a stable identity and clearly associated attributes. When applicable, record its:
- Variant or offer ID
- Name
- SKU
- Price
- Availability
- Condition
- Purchase URL
- Selected options
If a navy medium jacket is unavailable, an agent should not infer that it can be purchased merely because another color remains in stock.
Precise offer data prevents recommendations that look relevant but cannot actually fulfill the customer’s request.
6. Keep price and availability current
Stale commerce data is worse than incomplete data because it can produce a confident but incorrect recommendation.
Inventory and price can change far more quickly than a title or product description. Your publication process should account for those different rates of change.
At minimum:
- Update structured data when the storefront changes
- Regenerate feeds after catalog updates
- Remove discontinued offers
- Preserve explicit out-of-stock states
- Record when prices and availability were last observed
- Avoid serving expired promotional pricing
A machine-readable product should communicate not only its current value, but how recently that value was verified.
Agents need to distinguish between “in stock” and “was in stock when this page was last exported.”
7. Publish more than one machine-readable surface
There is no single interface used by every agent.
A resilient product-discovery strategy can include:
- Crawlable product pages
- Product JSON-LD
- XML sitemaps
- CSV or JSON catalog feeds
- REST search endpoints
- Model Context Protocol tools
- Universal Commerce Protocol capabilities
These channels serve different purposes.
Feeds are effective for bulk ingestion. REST is widely understood by application developers. MCP gives tool-using agents a standardized way to search and retrieve data. The Universal Commerce Protocol includes catalog search and lookup capabilities designed around agentic commerce.
You do not necessarily need to implement every protocol yourself. The goal is to avoid making one crawler, platform, or proprietary integration the only path into your catalog.
8. Establish merchant authority
An agent should be able to tell whether product information came from the merchant, an authorized distributor, or an unrelated third party.
Merchant authority can be supported through:
- Verified control of the source domain
- Consistent organization information
- Canonical product links
- Stable merchant identifiers
- First-party feeds
- Clear source attribution
- Traceable observation records
This becomes increasingly important when several sites publish conflicting details about the same product.
A recommendation system needs a reason to trust one source over another.
9. Test the page as a machine
Do not evaluate discoverability exclusively through a normal browser.
Inspect what a basic HTTP client receives. Disable JavaScript. Validate your JSON-LD. Check your sitemap. Confirm that product images and canonical URLs are publicly accessible.
Then test searches based on ordinary customer intent rather than exact product titles.
Instead of searching only for:
"TrailGuard Model 8400"
try:
"Waterproof hiking backpack with laptop storage under $150"
The second query is much closer to how an agent might encounter an unknown product.
If your catalog can only retrieve an item when the requester already knows its exact name, it has not solved product discovery.
A practical agent-discovery checklist
Before considering a product machine-ready, confirm that:
- The product has one stable canonical URL
- The page is publicly accessible
- Essential information appears without required interaction
- Product and Offer structured data validate correctly
- The visible page and structured data agree
- Variants have distinct identities and attributes
- Price and availability are current
- Images are accessible and properly described
- The merchant can be identified
- The product appears in the store’s sitemap or feed
- Natural-language searches can retrieve it
- Discontinued products are withdrawn cleanly
This is not a replacement for traditional SEO. It is an extension of it.
Making the catalog agent-ready with Nexus
Merchants should not need to become protocol engineers to participate in agentic commerce.
ULIX Nexus discovers products from a verified storefront, converts them into maintained canonical commerce records, and publishes those records through several machine-readable interfaces.
Nexus supports public intent search, REST, MCP, UCP, structured product representations, and catalog feeds. It also tracks source evidence and refreshes product information over time.
The original storefront remains the destination for the customer. Nexus provides the discovery layer that helps an agent reach it.
Developers and AI agents can inspect the available discovery channels through the Nexus agent gateway.
Merchants can connect their catalogs through the Nexus console without rebuilding their stores around a new protocol.
Make the product easy to choose
The objective is not simply to expose more data.
It is to remove uncertainty.
When an agent receives a shopping request, every unclear attribute becomes a reason to omit a product or recommend something else. Complete structure, current observations, and verified authority make the decision easier.
The storefront will continue serving people.
The machine-readable catalog serves the software increasingly searching on their behalf.