Traditional search was just a human browsing through a simple list, but in the age of AI, it’s become more complex than ever. Agentic search involves an LLM reading over your product pages or the structured catalog directly, making assumptions and decisions and finally summarizing its findings for the end user. That makes it hard for merchandisers, since the old methods of getting our products in front of the eyes of potential customers are no longer as effective. How do we create actionable product listings for AI-assisted shoppers then? Well, first we must grasp an important distinction.

Where the LLM lives matters

A user asking ChatGPT where to buy the best quality shoes on a budget is giving that LLM a wide-ranging task. It doesn’t just search through your website — OpenAI and other AI companies give their models Internet-wide search engines that might happen to pull up your site if the query matches your site’s content well enough. However, they don’t inherently have access to your structured product catalog, since they’ll be learning about your products by viewing the associated webpages. More on that in a minute.

On the other hand, a user on your website interacting with an LLM through your purpose-built interface will be expecting to learn about your products only. And if you set it up right — say, through Algolia’s Agent Studio — you can have that AI model generate its responses based directly on your structured catalog data, eliminating hallucinations while also giving you power over the model’s prompt. Using a tool like Agent Studio that sets up the plumbing for you between your product data store and your LLM and its UI is the most foolproof way of maximizing revenue with little effort.

However, many shoppers will first hear about your products indirectly through one of the big LLM interfaces like ChatGPT, Gemini, or Claude. Assuming we’ve already done the work to capture the interest (and credit card information) of the users who directly visit our site, can we tailor product pages to the public LLMs that will inevitably be reading them on the shoppers’ behalf? There’s a few low-hanging fruit principles to apply.

Principle 1: Data atomization

LLMs can parse a wall of text, but it isn’t the most effective strategy. LLMs are looking for answers to individual questions, and when those answers are buried in paragraphs between other bits of less-relevant information, it’s not going to be able to effectively pull the correct answers from your page. To an agent, the friction involved in processing that "Wall of Text" description is just too high — it’ll just search elsewhere given the means.

Agents perform best when they can filter and sort programmatically before synthesizing an answer, so deconstruct complex attributes into their components and normalize all units across products. This lets the AI perform logical comparisons with structured, atomized data.

Then, we can pass that new structure to the LLM using a few different techniques:

• JSON-LD — A trimmed down, standardized version of your product record in the official Product schema can be served inside your HTML for the agents like ChatGPT that rely on it to understand a page quickly.
• Embedded tables — Tables are a great way to make comparisons and show complex datasets while keeping the structure the LLM needs.
• Semantic markup — Ultimately, it’ll still read the page’s content, so break down strings into shorter elements that each describe one unit of meaning if possible.

Make sure that however you include this readable data in the webpage, it’s immediately accessible without JavaScript. The LLM isn’t going to click Read More buttons and the like, so your atomized data needs to be present in the original HTML payload. The ideal solution is to just render that info server-side to avoid the possibility that the agent reads an empty shell of a page.

Principle 2: Conversational copy

Agents don't just match keywords; they match intent. The user may ask for “blue cocktail dress”, but they may also ask the agent “I’m looking for a dress for a cocktail party on Tuesday”. For the first query, the agent’s lookup process is rather straightforward. But the latter query requires interpretation — the agent needs to understand the shipping timeline for each product to tell if it’ll arrive by Tuesday, and it has to understand the vibe of each product from its description to extrapolate whether it’ll be appropriate for a cocktail party.

How do we make it easier for the agent to answer these intent-filled conversational queries? With intent-filled conversational copy. Our product records should have keyword tags and descriptive descriptions that highlight the vibe and product usage. Those product descriptions should be to-the-point as well, since LLMs with research capabilities like ChatGPT often prefer quotes (even whole paragraphs verbatim) that directly answer the question at hand, without marketing fluff and jargon. In other words, agent searchers will prefer “This dress is perfect for a cocktail party” to “This is the best cocktail dress you’ll ever wear”, and your human customers will appreciate the authenticity too. Including a compact description in a fields in the JSON-LD the agent will read first is an extra way to get those few, AI-persuasive sentences in its context window.

Principle 3: Precision and specificity

An agent needs to know exactly what it is looking at and how it relates to the rest of your ecosystem to avoid a situation where the agent mistakenly promises the user that the product in question is definitely compatible with some other product, or makes some other confident guarantee that isn’t accurate. For parts or accessories, we can put an array on the product record that specifies exactly what other SKUs this particular part is compatible with. Remember, we don’t need to have the same keys on every product record, as long as we’re just including them in the JSON-LD and not trying to search by them. Same goes for product availability, shipping estimates, and anything else the agent would need to know precisely — specify them by including them in the product record. If any of that information should be searchable (for example, if you’ll allow the shoppers to filter only for products in stock), then you could supplement the records using Data Transformations or triggered updates through the API when the inventory system hits certain thresholds (like updating the Algolia index to record if a product is in_stock, low_stock, or out_of_stock instead of keeping an exact count). If that information doesn’t need to be in the product record go, you could easily pull it from another source on the product page itself. Whatever you choose, keeping the API call count down will make sure your upgrades for AI users don’t impact performance significantly for human users.

Principle 4: Proof of trustworthiness

If an agent cannot verify the source of the information, it may discard the result or flag it as low-confidence. All of the previous principles help build the impression of trustworthiness to the AI agent, but a few extra tips can help:

• Timestamps — Depending on its instructions, the agent might try to prioritize fresh data over stale listings. Without created_at and updated_at timestamps, it doesn’t really have a reliable way of setting your product page apart from outdated pages on defunct store sites that nobody has bothered to take down yet.
• Source URLs — The agent might be able to assume the canonical link to your product page based on what URL it visited to find that info, but that might not be the exact URL you want in the “Buy Now” button the shopper ends up seeing. For example, you might want the shopper sent directly to a Buy Now checkout flow that skips the product page entirely, or you might want a particular utm_source in the link for your analytics to track that the user came from an AI agent. Even if you don’t want a special URL for this, still include a canonical link in the JSON-LD since the agent might have visited your product page using a link with random GET parameters.
• Consistency — The agent might read your JSON-LD, then decide what to read on the rest of your page. If the details in that plaintext description later on the page don’t match the JSON-LD, then you immediately lose the agent’s trust.

How to win the agentic commerce game

When ChatGPT or Gemini "browses" your site, it isn't looking for keywords like traditional search engines — it's looking for the confidence to make a recommendation. Every bit of friction you remove increases the likelihood that that AI recommends your product to the shopper its assisting. The way to win the agentic commerce game, besides building the agent yourself on your own site, is to make every product page easily accessible, legible, and trustable by external agents like ChatGPT, Gemini, and Claude. And since your search index is often the source of truth for the JSON-LD and product data, making your site AI-ready starts with Algolia.

Ready to get started? Start auditing your product data today with Algolia’s suite of AI tools.