# What Is an Agent-Ready Product Catalog?

> An agent-ready catalog serves four machine surfaces. Here is what each one is, which AI assistants actually consume it, and how to tell your level.

**Published:** 2026-08-09  
**Category:** Solution · **Tags:** agent-ready, MCP, product data, AI search, structured data, agentic commerce  
**Canonical:** https://partsgraph.ai/blog/what-is-an-agent-ready-product-catalog

## In short

**What is an agent-ready product catalog?**

An agent-ready product catalog is one a machine can find, read, query and cite correctly without a human driving a browser. In practice it means four distinct surfaces: server-rendered pages carrying structured data that non-JavaScript crawlers can parse, clean text views of the same records, product feeds pushed to the assistants that only accept pushed data, and a hosted MCP endpoint agents can call directly. The four are not interchangeable — each is consumed by a different set of assistants — and none of them works without one canonical, verified product record underneath.

---

## What does "agent-ready" actually mean?

A product catalog is agent-ready when a machine can find it, read it, query it and cite it correctly without a human driving a browser.

That is a stricter test than "we have a good website", and it fails for reasons that never show up in a page-speed report. A catalog can rank well, convert well and look immaculate, and still return an empty document to the client that an AI assistant actually uses. The gap is structural, not cosmetic.

It also matters more each quarter. Writing up its Buyers' Journey Survey in January 2026, Forrester reported that 94% of business buyers now use AI in their buying process, and that twice as many buyers named generative AI or conversational search a more meaningful source of information than any other — ahead of vendor websites, product experts and sales representatives. The specifications an assistant recites about your product are increasingly the specifications your buyer believes.

The confusion in most writing on this topic is that "agent-ready" is treated as one thing. It is four things, with four different consumers.

## Which assistants actually consume which surface?

| Surface | What it is | Who consumes it today | What it cannot do |
| --- | --- | --- | --- |
| Server-rendered structured data | HTML delivered complete by the server, with schema.org JSON-LD that matches the visible text | Retrieval and search crawlers: OAI-SearchBot, Claude-SearchBot, PerplexityBot, Googlebot for AI Overviews and AI Mode | Return live stock, honour contract pricing, or answer a parametric query |
| Markdown / clean text views | Low-noise text renderings of the same records, sometimes at `.md` URLs or behind content negotiation | No consumer assistant documents a content-negotiation contract; useful mainly as extraction-friendly source text and as MCP payloads | Get you indexed on its own; it is not a ranking mechanism |
| Pushed product feeds | Structured catalog files you deliver to the assistant on a schedule | ChatGPT's shopping surface and Perplexity's merchant index, both of which require you to push — neither crawls your site for this | Carry engineering depth; retail feed schemas assume GTIN, list price and a buyable SKU |
| MCP endpoint | A hosted server exposing typed tools an agent calls over HTTP | Claude (all plans), ChatGPT developer mode and apps, Gemini Enterprise, Copilot, IDE agents, and your customers' own agents | Reach the anonymous long tail; the user or their administrator must connect it |

### 1. Server-rendered pages with structured data

This is the only surface that reaches an assistant user who has configured nothing.

The single most important technical fact about it: AI crawlers do not run your JavaScript. Vercel's crawler analysis — 569 million GPTBot fetches and 370 million Claude fetches in a single month — found that while these crawlers do download JavaScript files (11.50% and 23.84% of requests respectively), they do not execute them, and concluded that "none of the major AI crawlers currently render JavaScript", naming OpenAI, Anthropic, Meta, ByteDance and Perplexity. Independent re-testing through 2026 has reached the same verdict. If your parametric table, your stock indicator or your document list is injected client-side, it does not exist to these clients. Googlebot renders JavaScript and remains the exception, which is exactly why teams who check their visibility in Google conclude, wrongly, that everything is fine.

Google's own guidance is refreshingly blunt about the rest: to appear in AI Overviews or AI Mode "a page must be indexed and eligible to be shown in Google Search with a snippet", and there are no additional technical requirements, no AI-specific schema and no special files. Structured data still earns its place, because it removes ambiguity about which number is the rated current and which is the peak — but it is a disambiguation tool, not a magic trigger.

Finally, the crawler layer has a policy dimension most catalogs ignore. OpenAI documents three separate agents — GPTBot for foundation-model training, OAI-SearchBot for surfacing sites in ChatGPT search, and ChatGPT-User for user-initiated fetches. Anthropic documents ClaudeBot, Claude-User and Claude-SearchBot on the same pattern. They are independent `robots.txt` entries. A blanket disallow aimed at training also switches off the retrieval crawler that could have cited you.

### 2. Markdown and clean text views

This is the surface most over-claimed in 2026, so be precise about it.

No mainstream consumer assistant publishes a content-negotiation contract that says "send me `Accept: text/markdown` and I will prefer it". The `llms.txt` convention is technically coherent and has real adoption among developer-documentation sites, but Google states outright that you do not need AI text files to appear in its AI features, and adoption research through 2026 found OpenAI, Google and Anthropic crawlers do not request the file in meaningful volume.

What is genuinely true is narrower and still worth doing. Text extracted from a nav-heavy, script-heavy page is noisier than text served as prose, so clean views survive extraction better. And the same clean rendering is exactly what your MCP tools should return as their payload. Build markdown views as a reuse artefact of the canonical record, not as a growth tactic, and you will not be disappointed.

### 3. Pushed product feeds

Here is the fact that reorders most roadmaps: ChatGPT's shopping surface is fed by data merchants push, not by crawling. Under the published feed specification, merchants deliver TSV, CSV, XML or JSON to a mutually agreed, allow-listed endpoint over encrypted HTTPS, and the system accepts updates every 15 minutes. Perplexity's merchant programme works the same way in shape — product data supplied as CSV or XML files in a specified format, delivered by the merchant. No amount of on-page optimisation substitutes for enrolment.

The honest caveat for industrial catalogs is that these schemas are retail-shaped. They assume a GTIN, a list price and a buyable variant. A distributor with 40,000 lines, customer-specific contract pricing and no GTIN on half the range will find the fit poor. Feeds are high-value where you sell a published price to an identifiable end buyer, and largely irrelevant where you quote.

### 4. An MCP endpoint

MCP is the highest-fidelity surface and, today, the narrowest audience. Precision matters here because reach differs sharply by assistant:

- **Claude** supports custom remote MCP connectors on Free, Pro, Max, Team and Enterprise plans, with free users limited to one connector. The server must be reachable over the public internet from Anthropic's IP ranges.
- **ChatGPT** exposes custom MCP servers through developer mode; write-capable custom connectors are limited to Business, Enterprise and Edu, while individual Plus and Pro users get read-only ones. The Apps SDK, which powers apps inside ChatGPT, is itself built on MCP and submissions go through directory review.
- **Gemini** offers custom MCP server connections through Gemini Enterprise, where an administrator registers your Streamable HTTP server as a data store inside their tenant. It is not a consumer feature.

So the reachable population is engineers who configure a connector, and enterprise buyers whose IT function registers your server. For a component or building-product manufacturer, that is a remarkably good description of the specifier and the procurement team — but it is not the anonymous long tail, and anyone telling you an MCP endpoint alone makes you "AI visible" is selling something.

## Why is an empty MCP server worthless?

Because a tool call is a promise of correctness, and a wrong answer delivered through a tool is worse than no answer at all.

When an assistant reads your web page, it hedges: the model knows it is summarising a document. When it calls `get_part` and receives `{"rated_current_a": 32}`, it does not hedge. It states the figure. If your PIM holds 32 A for the frame size and 25 A for the specific variant, and the tool resolved to the wrong one, you have not improved your AI visibility — you have industrialised a specification error and attached your brand's authority to it.

That is why the credible parts MCP servers shipping today are built on a verified data layer rather than a protocol veneer. Microchip's free public MCP server, launched in November 2025, exposes verified product specifications, datasheets, inventory, pricing and lead times over Streamable HTTP — the announcement's emphasis is on *verified, up-to-date* data, not on the transport. Shopify's Storefront MCP server, reachable at `https://{shop}.myshopify.com/api/mcp`, works because a Shopify store already has one authoritative product record with typed fields.

An MCP endpoint in front of three disagreeing spreadsheets, a PIM that lost its units, and a folder of PDFs is a faster way to be wrong. The order of work is: canonical record, verification, then protocol.

## The agent-readiness maturity model

| Level | Name | What is true at this level | Typical failure |
| --- | --- | --- | --- |
| 0 | Invisible | Client-rendered catalog; specifications live only inside PDFs; no structured data | A non-browser client receives an empty shell |
| 1 | Crawlable | Server-rendered product pages; schema.org markup matching visible text; an explicit, deliberate AI-crawler policy in `robots.txt` | Blanket training block also silences the retrieval crawlers |
| 2 | Extractable | One canonical part record; parametrics typed against a shared dictionary (ETIM, ECLASS, UNSPSC); documents modelled as records, not links; stable identifiers | Attributes exist but disagree between web, PIM and datasheet |
| 3 | Callable | Hosted MCP endpoint over Streamable HTTP with parametric search, part lookup, alternates, compliance documents and CAD; feeds pushed where the surface exists | Tools ship without freshness or provenance, so nobody can audit an answer |
| 4 | Authorised agent channel | OAuth-gated stock and contract pricing per customer; continuous accuracy monitoring; agent analytics; a published policy for what agents may access | None, if the monitoring is real — this is the target state |

Most organisations discover they are at level 0 or 1 while believing they are at level 2. The distinguishing question is not "do we have structured data?" but "if two systems disagree about this attribute, which one is right, and can a machine tell?"

## How do you find out which level you are on?

Five checks, in order, each of which takes minutes:

1. **Fetch a product page with a plain non-browser client** and read the raw response. If the specifications are absent from the HTML, you are at level 0 regardless of what the page looks like in a browser.
2. **Read your `robots.txt` as a policy document.** List every AI user agent you allow and disallow, and confirm each line reflects an actual decision about training versus retrieval.
3. **Validate one JSON-LD block** and check every value against the visible page. Mismatches are worse than omissions.
4. **Pick ten parts and ask three assistants a factual question** whose correct answer you know cold. Record the wrong answers. That error rate is your real baseline.
5. **Try to answer a parametric question from your own data** — every part meeting three constraints — using only what a machine can reach. If a human has to open a PDF, so would an agent, and it will not.

## What did we find across 984 companies?

In August 2026 we audited 984 distributor and manufacturer domains worldwide, across North America, Europe and Asia. The aggregate picture was consistent enough to be uncomfortable:

- The median AI-visibility score was around 50 out of 100.
- 38% served no readable catalog page at all to a standard non-browser client.
- Only 19% published an explicit AI-crawler policy of any kind, and among those, more than twice as many blocked a major crawler as invited one.
- None advertised an MCP endpoint.

The distribution matters more than the median. The gap between the top decile and the middle was not budget or headcount; it was whether the organisation had one canonical product record or several competing ones. Everything else followed from that.

## What should you build first?

1. **Establish one canonical record per part**, with typed attributes, units, provenance and a last-verified timestamp. Everything below is a projection of this.
2. **Server-render the catalog** so the full specification is present in the initial HTML response.
3. **Add structured data that matches the page**, then verify it rather than trusting the generator.
4. **Write a deliberate AI-crawler policy**, agent by agent, and document why each decision was made.
5. **Push feeds where a surface exists for your commercial model** — and skip them honestly where it does not.
6. **Stand up an MCP endpoint** exposing parametric search, part lookup, alternates, compliance documents and CAD, with OAuth for anything customer-specific.
7. **Monitor accuracy continuously**, because the failure mode is not silence, it is confident error.

Partsgraph builds this as an overlay: we ingest the catalog you already have — datasheets, parametrics, CAD and compliance documents — resolve it into one verified Parts Graph, and serve it across all four surfaces without touching your website.

If you want the baseline before the roadmap, run your domain through our free grader at [/audit](/audit). It reports what a non-browser client actually receives from your catalog today, and which of the four surfaces you are missing.

## Common questions

### Is an agent-ready catalog just SEO with a new name?

No, though it overlaps. Classic SEO optimises one surface — a crawlable HTML page — for one consumer, a search index. Agent-readiness spans four surfaces with different consumers, two of which (pushed feeds and MCP) are not crawled at all: you actively deliver data to them. The overlap is real at the crawl layer, where Google's own guidance is that AI Overviews and AI Mode draw on the same index and the same technical requirements as ordinary Search.

### Do I need llms.txt?

Almost certainly not as a priority. Google states plainly that you do not need to create new machine-readable files or AI text files to appear in its AI features, and independent adoption analysis in 2026 found the major AI crawlers do not request llms.txt in meaningful volume. It costs little to publish one, but it should never displace server-rendered pages, a feed, or an MCP endpoint on your roadmap.

### Which single surface should a manufacturer build first?

Server-rendered, structured product pages — because that is the only surface reaching the anonymous long tail of assistant users, and because it forces you to build the canonical product record that every other surface reuses. Feeds and MCP are cheap once the record exists and near-impossible before it does.

### Can AI assistants read a PDF datasheet?

Sometimes, badly, and unpredictably. A crawler that reaches a PDF may extract text from it, but tables, footnoted conditions and multi-column parametrics degrade heavily, and the resulting values arrive without units, tolerances or test conditions attached. A PDF is a rendering of your data, not your data. The fix is to hold the parametrics as structured records and keep the PDF as one representation among several.

### Does an MCP endpoint replace my website?

No. MCP is deployed alongside the website, not instead of it. It reaches a narrower but higher-intent audience: engineers who configure a connector, and enterprise buyers whose IT administrator registers your server. The public web still carries the anonymous majority of assistant traffic, so the two channels serve different halves of the same funnel.

### How do I know whether AI assistants are reading my catalog correctly?

Test it rather than assume it. Fetch your own product pages with a plain non-browser client and see what comes back; ask several assistants factual questions about parts whose correct answers you know; and instrument any MCP endpoint or feed so you can see which parts are being requested and which lookups fail. Accuracy monitoring matters more than volume — a confidently wrong specification does more commercial damage than an absent one.

### What does level 4 give me that level 3 does not?

Authorisation and observability. At level 3 an agent can query your public catalog. At level 4 an authenticated agent can see contract pricing and live stock for a specific customer, you can see which agents queried what, and you can measure whether the answers they were given were correct. That turns an SEO-adjacent project into a channel with a permission model and metrics.

## Sources

1. [Vercel, The rise of the AI crawler (crawl volumes and JavaScript rendering analysis)](https://vercel.com/blog/the-rise-of-the-ai-crawler)
2. [SearchOptimo, Do AI crawlers render JavaScript? GPTBot, ClaudeBot and Perplexity in 2026](https://searchoptimo.com/blog/do-ai-crawlers-render-javascript)
3. [Google Search Central, AI Features and Your Website](https://developers.google.com/search/docs/appearance/ai-features)
4. [Google Search Central, Guide to optimizing for generative AI features](https://developers.google.com/search/docs/fundamentals/ai-optimization-guide)
5. [OpenAI, Overview of OpenAI crawlers (GPTBot, OAI-SearchBot, ChatGPT-User)](https://developers.openai.com/api/docs/bots)
6. [Anthropic, Does Anthropic crawl data from the web, and how can site owners block the crawler?](https://support.claude.com/en/articles/8896518-does-anthropic-crawl-data-from-the-web-and-how-can-site-owners-block-the-crawler)
7. [Agentic Commerce Protocol, Product Feed Specification](https://agentic-commerce-protocol.com/docs/commerce/specs/feed)
8. [OpenAI Developers, Product feeds (Agentic Commerce)](https://developers.openai.com/commerce/specs)
9. [Perplexity, Merchant Program Terms of Service](https://www.perplexity.ai/hub/legal/merchant-program-terms-of-service)
10. [Anthropic, Get started with custom connectors using remote MCP](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp)
11. [OpenAI Help Center, Developer mode and MCP apps in ChatGPT](https://help.openai.com/en/articles/12584461-developer-mode-and-mcp-apps-in-chatgpt)
12. [Google Cloud, Set up your custom MCP server data store (Gemini Enterprise)](https://docs.cloud.google.com/gemini/enterprise/docs/connectors/custom-mcp-server/set-up-custom-mcp-server)
13. [Model Context Protocol, MCP joins the Agentic AI Foundation (9 December 2025)](https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/)
14. [Shopify, Storefront MCP server documentation](https://shopify.dev/docs/apps/build/storefront-mcp/servers/storefront)
15. [Microchip Technology, Microchip unveils Model Context Protocol (MCP) Server (6 November 2025)](https://ir.microchip.com/news-events/press-releases/detail/1344/microchip-technology-unveils-model-context-protocol-mcp-server-to-power-ai-driven-product-data-access)
16. [Forrester, B2B Buyers Make Zero-Click Buying Number One (22 January 2026, Buyers' Journey Survey)](https://www.forrester.com/blogs/b2b_buyers_make_zero_click_buying_number_one/)
17. [Presenc AI, State of llms.txt 2026 (adoption and crawler request data)](https://presenc.ai/research/state-of-llms-txt-2026)

---

Partsgraph — the agent-ready parts data layer. Free AI-visibility grader: https://partsgraph.ai/audit