<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
  xmlns:content="http://purl.org/rss/1.0/modules/content/"
  xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Hidden Layer — GEO &amp; Agent-Readiness Research</title>
    <link>https://hidden-layer-blogs.pages.dev/blog</link>
    <description>Agent-readiness audits and GEO research for the AI era.</description>
    <language>en-US</language>
    <lastBuildDate>Tue, 12 May 2026 00:00:00 GMT</lastBuildDate>
    <atom:link href="https://hidden-layer-blogs.pages.dev/feed.xml" rel="self" type="application/rss+xml" />

    <item>
      <title>The GEO leaderboard: who&apos;s winning AI visibility in 2026</title>
      <link>https://hidden-layer-blogs.pages.dev/post/geo-leaderboard-2026</link>
      <guid isPermaLink="true">https://hidden-layer-blogs.pages.dev/post/geo-leaderboard-2026</guid>
      <pubDate>Tue, 12 May 2026 00:00:00 GMT</pubDate>
      <description>Agent integration = 0 across all 118 domains. The agentic web is coming but zero companies have started building for it.</description>
      <content:encoded><![CDATA[# The GEO leaderboard: who's winning AI visibility in 2026

> Agent integration = 0 across all 118 domains. The agentic web is coming but zero companies have started building for it.

**Category:** Leaderboard | **Date:** 2026-05-12 | **Read:** 10 min

---

Agent Integration scored 0/13 across all 118 domains in every industry category. Zero. Not one company in our dataset has deployed agent-specific endpoints, structured tool responses, or machine-readable capability declarations. The agentic web is being built, but the companies that will populate it aren't preparing for it.

## The expanded leaderboard

118 domains across 12 industries. Here are the top 10; the full dataset includes F-grade domains like hm.com (F/14), adidas.com (F/15), and freshworks.com (F/17).

| Rank | Domain | Grade/Score |
| --- | --- | --- |
| 1 | twilio.com | B/86 |
| 2 | akeneo.com | B/85 |
| 3 | cloudflare.com | B/84 |
| 4 | samsung.com | B/84 |
| 5 | atlassian.com | B/84 |
| 6 | nike.com | B/80 |
| 7 | shopify.com | B/79 |
| 8 | render.com | B/77 |
| 9 | allbirds.com | B/76 |
| 10 | notion.so | B/76 |

## Industry benchmarks

| Industry | Median Score | N |
| --- | --- | --- |
| Consumer Electronics | C/72 | 4 |
| B2B SaaS | C/65 | 36 |
| Financial Services | D/59 | 7 |
| Developer Tools | D/59 | 20 |
| AI/ML | D/55 | 14 |
| Marketplace | D/54 | 3 |
| Footwear | D/53 | 3 |
| Entertainment | D/53 | 6 |
| Media & Publishing | D/50 | 10 |
| Fashion | F/41 | 4 |
| Social Media | F/36 | 5 |
| Sportswear | F/35 | 4 |

## Pattern 1: Bot access is solved — AI visibility isn't

Every domain achieved the maximum 75/75 on Bot Access. Technical infrastructure is no longer the constraint. But AI Visibility ranges 12–18/68 median — LLMs can reach your content but don't know what it means. The gap between accessibility and understandability is 57 points wide.

## Pattern 2: AI companies are getting worse, not better

OpenAI dropped to D/57 (was C/62). Anthropic fell to D/48 (was C/52). Vercel crashed from #1 at B/82 to #14 at C/70 — partly because Vercel's own robots.txt now includes 'ai-train=no', an explicit AI training block that penalises its score. These are the companies building the models — yet they're among the worst at making their own content discoverable to those same models.

## Pattern 3: The within-category canyon

In Sportswear: Nike B/80 vs Adidas F/15 — a 65-point gap. In B2B SaaS: Twilio B/86 vs Freshworks F/17 — a 69-point gap. Nike and Twilio built API-first infrastructure; Adidas and Freshworks use marketing-page-first architectures. The structural choice, made years before GEO existed, determines whether you're invisible to agents.

## What separates B from F

- Agent integration endpoints (0/13 across all 118 domains) — no company has started; first mover advantage is completely unclaimed
- Entity linking to knowledge graphs — Wikipedia/Wikidata sameAs on Organisation schema; GEO Presence median is 18–30/46
- llms.txt implementation — AI Discovery plateaus at 12–15/20 median without it; Shopify has it, Anthropic doesn't
- Render gap — AI Visibility at 12–18/68 reflects JavaScript-heavy pages that serve thin HTML shells to crawlers

## What nobody has done yet

No domain scored above 0 on Agent Integration. The category covers /.well-known/agent-card.json (A2A protocol), /.well-known/oauth-protected-resource (RFC 9728), and MCP discovery endpoints. These are a day's work each. Zero companies have shipped any of them. Being the first in your industry category to hit 1/13 is a genuinely differentiating signal right now.

## Where to start if you're C, D, or F

1. Deploy llms.txt at your root with current sitemap references — improves AI Discovery score by 12–15 points. Check llmstxt.org for current format.
2. Add entity links: Wikipedia and Wikidata sameAs on your Organisation and Product schema — boosts GEO Presence from the 18–30 range toward the 40s.
3. Implement structured product schema if you sell anything — Commerce scores are 0–2/2 across all 118 domains; this is table stakes.
4. File agent integration as a roadmap item — /.well-known/agent-card.json (A2A) and /.well-known/oauth-protected-resource (RFC 9728) are the next frontier. First movers will hold these positions.

Run your domain at hidden-layer-blogs.pages.dev to see where you rank.


**Tags:** Leaderboard, GEO, Rankings, AI Visibility]]></content:encoded>
      <category>Leaderboard</category>
      <tag>Leaderboard</tag>
      <tag>GEO</tag>
      <tag>Rankings</tag>
      <tag>AI Visibility</tag>
    </item>

    <item>
      <title>Agent integration: the 0/13 frontier</title>
      <link>https://hidden-layer-blogs.pages.dev/post/agent-integration-frontier</link>
      <guid isPermaLink="true">https://hidden-layer-blogs.pages.dev/post/agent-integration-frontier</guid>
      <pubDate>Tue, 12 May 2026 00:00:00 GMT</pubDate>
      <description>Hidden Layer audited 118 domains across 12 industries. Every single one scored 0/13 on agent integration. The frontier is completely open.</description>
      <content:encoded><![CDATA[# Agent integration: the 0/13 frontier

> Hidden Layer audited 118 domains across 12 industries. Every single one scored 0/13 on agent integration. The frontier is completely open.

**Category:** Agent Integration | **Date:** 2026-05-12 | **Read:** 8 min

---

Hidden Layer audited 118 domains across 12 industries. Every single one scored 0/13 on agent integration. Not one B2B SaaS company. Not one Developer Tools platform. Not one AI company. The agent integration category is the only one where the maximum score equals the minimum score across every domain in the dataset — and both are zero.

This isn't about companies doing it badly. It's that no one has started.

## What agent integration actually means

Agent integration means making your services discoverable and callable by AI agents through standardised protocols. Three files do most of the work:

- MCP server card (/.well-known/mcp.json) — declares your MCP server's capabilities, tools, and connection requirements to any agent that checks. The Model Context Protocol launched Nov 2024.
- A2A agent card (/.well-known/agent-card.json) — Google's Agent-to-Agent protocol, launched Apr 2025. Tells external agents your agent's name, skills, and how to invoke it.
- OpenAPI spec (/openapi.json) — a standard 3.1+ description of your REST API at a well-known path. Most companies publish this at /api/swagger or /docs — not the standardised location agents look for.

The three protocols are independent and complementary. MCP is about tool access. A2A is about agent-to-agent delegation. OpenAPI is about raw API discoverability. A B2B SaaS company could implement all three in a day.

## The 7 checks, ranked by opportunity

| Check | Points | What it requires | Est. time |
| --- | --- | --- | --- |
| OpenAPI spec | 3 | /openapi.json with OpenAPI 3.1+ spec | 20 min if spec exists |
| A2A agent card | 2 | /.well-known/agent-card.json (Google A2A spec) | 10 min |
| OAuth protected resource | 2 | /.well-known/oauth-protected-resource (RFC 9728) | 15 min |
| API catalog | 1 | /.well-known/api linking to API resources | 5 min |
| MCP server card | 1 | /.well-known/mcp.json declaring MCP capabilities | 10 min |
| Web Bot Auth | 1 | /.well-known/http-message-signatures-directory (IETF draft) | 10 min |
| Listed in MCP registry | 1 | Submit to registry.smithery.ai | 5 min |

## Who moves first?

Companies with existing REST APIs are already halfway there. Twilio and Stripe both have OpenAPI specs — they just live at non-standard paths. Moving them to /openapi.json is a one-line Nginx/Cloudflare rewrite. Adding an agent-card.json is JSON authoring.

Developer tools platforms (Cloudflare, Vercel, Render) are structurally ready. Their APIs are already public, documented, and designed for machines. Adding MCP and A2A discovery is a config file, not a product decision.

Content-only sites (media, fashion, consumer brands) are furthest away — they'd need to build APIs first. But most don't need to. Their play is llms.txt and entity linking, not MCP servers. Agent integration points are honestly irrelevant for a brand like Adidas.

The irony remains: AI companies (OpenAI D/57, Anthropic D/48) — whose products depend on agent interoperability — have zero agent integration signals on their own domains. The 0/13 applies to them as much as to anyone.

## First mover advantage is real

Today's 0/13 vs 0/13 looks equal. In 12 months it's 10/13 vs 0/13 — and the gap is permanent for the companies who move. Agent discovery works like SEO in 2004: the companies that invested early hold positions that are structurally hard to displace.

The Hidden Layer audit will add weight to these checks as adoption rises. Currently they're low-weighted because sub-1% of the web uses them — the methodology doesn't punish you for missing protocols that don't exist yet. But as Smithery grows, as A2A adoption rises, the weight increases. The first 30 companies in each industry to hit 5/13 will own that category's agent discovery ranking.

## How to implement the two highest-value checks

Start with A2A agent card (2 pts) and OpenAPI spec (3 pts). Together they're 5/13 — already ahead of 100% of the current web.

Create /.well-known/agent-card.json:

```
{
  "name": "Your Service Name",
  "description": "What your service does in one sentence",
  "url": "https://yourdomain.com",
  "version": "1.0.0",
  "skills": [
    {
      "name": "primary-capability",
      "description": "What agents can do with your service"
    }
  ]
}
```

Create /.well-known/mcp.json:

```
{
  "mcpVersion": "1.0.0",
  "server": {
    "name": "Your MCP Server",
    "version": "1.0.0",
    "description": "What tools your MCP server exposes"
  },
  "capabilities": {
    "tools": { "listChanged": true }
  }
}
```

Both files serve as static JSON from your web root. No backend logic required. Add a Nginx location block or a Cloudflare Pages static file and you're done. Run your domain at hidden-layer-blogs.pages.dev after deploying — you should see 3/13 immediately (A2A card + MCP card + at least one from the OpenAPI path check).


**Tags:** Agent Integration, MCP, A2A, GEO, Research]]></content:encoded>
      <category>Agent Integration</category>
      <tag>Agent Integration</tag>
      <tag>MCP</tag>
      <tag>A2A</tag>
      <tag>GEO</tag>
      <tag>Research</tag>
    </item>

    <item>
      <title>46+ checks, one grade: how we score AI readiness</title>
      <link>https://hidden-layer-blogs.pages.dev/post/scoring-methodology</link>
      <guid isPermaLink="true">https://hidden-layer-blogs.pages.dev/post/scoring-methodology</guid>
      <pubDate>Mon, 11 May 2026 00:00:00 GMT</pubDate>
      <description>A transparent look at the 8 categories, 229 base points, and why a B doesn&apos;t mean you&apos;re ready and an F doesn&apos;t mean you&apos;re invisible.</description>
      <content:encoded><![CDATA[# 46+ checks, one grade: how we score AI readiness

> A transparent look at the 8 categories, 229 base points, and why a B doesn't mean you're ready and an F doesn't mean you're invisible.

**Category:** Methodology | **Date:** 2026-05-11 | **Read:** 6 min

---

Hidden Layer runs 46+ checks across 8 categories and returns a letter grade from A to F. The methodology is transparent — here's the full rationale for what we check and why we weight it the way we do.

## The 8 categories

### 1. Discoverability (39 points max)

Can AI systems find you at all? This covers robots.txt presence and parse-ability, sitemap.xml structure (including sub-sitemap fan-out), HTTPS enforcement, and response headers. A domain with a 403 robots.txt gets a hard fail on bot access — we treat CDN blocks as equivalent to Disallow: *.

Why 39 points? Discovery is the precondition for everything else. A site that blocks crawlers doesn't get to score on agent integration.

### 2. Bot Access (75 points max)

The heaviest category. We check 12 canonical AI bot UAs against robots.txt rules: GPTBot, ClaudeBot, OAI-SearchBot, ChatGPT-User, Claude-SearchBot, Claude-User, PerplexityBot, Google-Extended, Applebot-Extended, CCBot, Meta-ExternalAgent, and Bytespider. We also score the training_search_mismatch signal — a site that blocks all training bots while allowing search bots takes a penalty because the combination signals an inconsistent AI policy.

We apply RFC 9309 inheritance: bots with no explicit section inherit the User-agent: * rule. A permissive wildcard rule is a pass for all uncovered bots. We weight retrieval bots (OAI-SearchBot, ChatGPT-User, Claude-SearchBot, Claude-User, PerplexityBot) higher than training bots — the immediate commercial impact of blocking search-type bots is larger.

### 3. AI Discovery (15 points max)

Is llms.txt present and parseable? We check for the file at /llms.txt, validate it has a top-level H1 and at least one section, and check for a /llms-full.txt companion. 15 points reflects that llms.txt is a genuine differentiator — present on under 20% of major domains — but not yet universal infrastructure.

### 4. Agent Integration (13 points max)

The emerging-standards category. These specs have <1% adoption across the web but signal forward-looking infrastructure. We weight each proportionally to its maturity:

- OpenAPI spec at standard well-known paths — 3pts (OpenAPI is established; well-known path discovery is new)
- /.well-known/agent-card.json (A2A protocol) — 2pts
- /.well-known/oauth-protected-resource (RFC 9728) — 2pts
- Listed in Smithery MCP registry — 2pts
- /.well-known/mcp.json (informal MCP card) — 1pt
- /.well-known/api catalog — 1pt
- /.well-known/http-message-signatures-directory (Web Bot Auth draft) — 1pt
- /.well-known/agent-skills/index.json — 1pt

### 5. AI Visibility (34 points max)

Content legibility and identity signals. This category measures how well AI systems can extract meaning from your site:

- JSON-LD structured data (Schema.org) — 8pts: the primary machine-readable identity signal
- Open Graph meta tags — 5pts: used for content preview and entity extraction
- sameAs entity linking — 5pts: links your domain to Wikidata, Wikipedia, LinkedIn in JSON-LD
- Content efficiency (text-to-HTML ratio) — 5pts: JS-heavy sites penalised for AI legibility
- Content-Signal directive (robots.txt or X-Robots-Tag) — 3pts
- Speakable Schema.org markup — 2pts
- /pricing.md machine-readable pricing — 2pts
- Agent-mode view (non-HTML response to AI UA) — 2pts
- Markdown content negotiation (Accept: text/markdown) — 2pts

### 6. GEO Presence (46 points max)

The GEO-specific category — measuring whether AI systems actually know and recommend your brand. This is what distinguishes Hidden Layer from infrastructure-only audits.

- LLM cold recall — 15pts: we probe a language model with no tools or context and ask it to describe your domain. Pass = model recognises and accurately describes you.
- LLM category share of voice — 10pts: we ask the model to list the top 10 brands in your industry. Pass = your brand appears.
- Wikipedia / Wikidata presence — 8pts: the strongest predictor of LLM citation accuracy in our dataset.
- HN mentions (Algolia HN API) — 5pts: HN is a high-weight LLM training corpus source.
- Brand-name search (DuckDuckGo instant) — 5pts: brand search returns your domain.
- Reddit mentions — 3pts: community corpus presence.

### 7. Commerce (2 points max)

Payment-pointer and x402 protocol presence. Very early-stage — most sites score 0 here. This will expand as AI-native payment protocols mature.

### 8. Product Pages (variable)

For domains with e-commerce product pages, we auto-discover product URLs from the sitemap and audit up to 10 pages for Schema.org product schema (Product, ProductGroup, IndividualProduct), completeness of offers/price/availability, image and brand presence, and aggregate ratings. Scored as a percentage of observed product page completeness; weight adjusts to domain size.

## The grade scale

| Grade | Score | What it means |
| --- | --- | --- |
| A | 90–100% | AI-optimised: llms.txt, strong discoverability, explicit bot policies, schema complete |
| B | 75–89% | AI-friendly: bots allowed, llms.txt present, some GEO signals in place |
| C | 60–74% | AI-accessible: core discoverability works, higher-order signals missing |
| D | 45–59% | AI-limited: significant blocks or gaps, agents struggle to get accurate information |
| F | 0–44% | AI-inaccessible: CDN blocks, critical failures, or deliberate AI exclusion |

## Common misreads

"A D score means AI can't find us." Not necessarily. A D often means you're accessible but haven't implemented bot-access rules or llms.txt explicitly. Agents can still reach you; they have less policy certainty and fewer curated signals to work from.

"An A means we're done." The spec is evolving. An A today is passing the current 46+ checks. Weights will shift as adoption rises — A2A and OAuth resource metadata are currently at 1–2pts because <1% of sites implement them. When 10% do, the weight goes up.

"Low score is about content quality." We don't score content. We score discoverability, access signals, and LLM-observable presence. A site with brilliant content behind a CDN firewall scores the same as a site with no content behind the same firewall.

"The LLM check is subjective." The GEO Presence checks use a deterministic probe with a fixed model (llama-3.1-8b via CF Workers AI) and structured parsing. The same domain at the same time should return the same result. The model is updated by CF — results may shift when the model checkpoint updates.

## What we don't check (yet)

Render gap analysis requires a headless browser — measuring what JS-rendered content looks like to AI crawlers vs what the raw HTTP response contains. Not free at scale, so it's not scored. It's the biggest single gap in the current methodology.


**Tags:** Scoring, Methodology, Agent Readiness]]></content:encoded>
      <category>Methodology</category>
      <tag>Scoring</tag>
      <tag>Methodology</tag>
      <tag>Agent Readiness</tag>
    </item>

    <item>
      <title>Product schema in the AI era: why your store&apos;s JSON-LD is now table stakes</title>
      <link>https://hidden-layer-blogs.pages.dev/post/product-schema-ai-commerce</link>
      <guid isPermaLink="true">https://hidden-layer-blogs.pages.dev/post/product-schema-ai-commerce</guid>
      <pubDate>Mon, 11 May 2026 00:00:00 GMT</pubDate>
      <description>AI shopping agents don&apos;t browse — they parse. If your product pages don&apos;t emit Product, Offer, and AggregateRating in server-rendered JSON-LD, you&apos;re invisible to the next wave of commerce traffic.</description>
      <content:encoded><![CDATA[# Product schema in the AI era: why your store's JSON-LD is now table stakes

> AI shopping agents don't browse — they parse. If your product pages don't emit Product, Offer, and AggregateRating in server-rendered JSON-LD, you're invisible to the next wave of commerce traffic.

**Category:** Structured Data | **Date:** 2026-05-11 | **Read:** 7 min

---

When a user asks ChatGPT 'what are the best sustainable running shoes under $150?', the model doesn't open a browser and shop. It draws from training data and, increasingly, from real-time agent-browsing where AI tools fetch product pages and extract structured information. What they find — or don't find — determines whether your products appear in AI-generated recommendations.

The mechanism is product schema: JSON-LD embedded in your page HTML that declares product name, price, availability, ratings, brand, and identifiers in a machine-readable format. It's been used by Google for rich results since 2012. In 2026, it's become the primary signal AI shopping agents use to extract product information without running JavaScript.

## What AI agents actually extract from a product page

When an AI agent visits a product page, it issues an HTTP GET — the same request a curl command makes. It receives the server-rendered HTML. On a well-built commerce site, embedded somewhere in that HTML is a `<script type="application/ld+json">` block containing the product's canonical data.

An agent looking at a product page wants:

- name — the canonical product name
- offers — current price, currency, and availability (InStock / OutOfStock)
- image — at least one image URL for visual context
- description — a text description the agent can cite or summarize
- brand — brand name for attribution
- aggregateRating — review score and count (trust signal)
- sku or gtin13 — product identifiers for comparison across retailers

If that JSON-LD block is missing, the agent has to parse free-form HTML — notoriously unreliable — or return nothing. A missing schema block is a silent revenue leak: the product exists, but AI agents can't reliably describe or recommend it.

## Shopify and ProductGroup: the variant schema problem

Shopify stores add a complication: variant products (a shoe in 10 sizes and 4 colours) emit `@type: ProductGroup` rather than `@type: Product`. ProductGroup is a Schema.org type introduced to handle this pattern — the group has name, brand, and offers, and each variant is nested under `hasVariant`.

This is correct Schema.org. But an AI agent — or an audit tool — checking for `@type: Product` will find nothing and score the page as missing product schema. Hidden Layer's product audit now accepts ProductGroup, IndividualProduct, and Product as valid types. But many third-party AI tools don't. If your Shopify store has been flagged as 'missing structured data' by SEO tools, check whether they're checking for ProductGroup.

```
// Valid Shopify product page schema (simplified)
{
  "@context": "https://schema.org",
  "@type": "ProductGroup",
  "name": "Allbirds Men's Tree Runners",
  "brand": { "@type": "Brand", "name": "Allbirds" },
  "image": "https://cdn.allbirds.com/image/upload/...",
  "description": "Lightweight running shoes made from eucalyptus tree fiber.",
  "offers": {
    "@type": "AggregateOffer",
    "priceCurrency": "USD",
    "lowPrice": "110",
    "highPrice": "145",
    "availability": "https://schema.org/InStock"
  },
  "hasVariant": [
    {
      "@type": "Product",
      "name": "Allbirds Men's Tree Runners — Size 10",
      "sku": "M_TR_10_NGMW",
      "offers": { "@type": "Offer", "price": "110", "priceCurrency": "USD" }
    }
    // ...103 more variants
  ]
}
```

## The five signals that determine your product schema score

Hidden Layer scores product pages against eight checks. The five most commonly missing:

| Signal | Points | Why it matters |
| --- | --- | --- |
| Product/ProductGroup schema present | 10 | Primary signal — without this, nothing else counts |
| offers with price + availability | 8 | AI agents need current price to recommend or compare |
| aggregateRating present | 6 | Trust signal — models weight review scores in recommendations |
| image URL present | 4 | Visual context for multimodal models and shopping interfaces |
| brand present | 3 | Attribution — links product to brand entity in training data |

Schema completeness matters beyond the audit score. When a model synthesises a product recommendation, it tends to name products it has complete, consistent information about. A product with name, price, brand, and reviews in structured data is more likely to be cited accurately than one where the model had to infer from free-form text.

## Discovery: can AI agents even find your product pages?

Structured data on product pages is only half the problem. AI agents also need to discover which pages are product pages in the first place. The primary mechanism is your sitemap.xml.

Shopify stores typically expose `/sitemap.xml` which links to sub-sitemaps by type: `/sitemap_products_1.xml`, `/sitemap_pages_1.xml`, etc. An agent that correctly fans out from the root sitemap will find all product URLs. But many Shopify themes use custom sitemap generators or disable the built-in sitemap entirely — leaving AI agents unable to discover the product catalogue without scraping navigation links.

The concrete test: fetch your sitemap.xml and count the product URLs. If that number is zero or suspiciously low, check your Shopify sitemap settings and whether your theme overrides the default.

## The bot access problem: WAF rules that block AI shopping agents

The second common failure mode is WAF rules. Cloudflare's Bot Fight Mode, enabled by default on many Shopify stores, blocks requests from non-browser user agents. AI shopping agents that browse product pages to extract information — OAI-SearchBot, Claude-User, PerplexityBot — arrive with non-browser UAs and get 403 responses.

A 403 on a product page doesn't just fail the request — it means the product catalogue is invisible to that AI system for all future requests until the block is lifted. Cloudflare's dashboard has a 'Verified Bots' policy that explicitly allows listed AI crawlers through WAF. Enabling it takes two minutes and restores access for every crawler on the list.

## Quick checklist: product AI-readiness in 30 minutes

1. Fetch a product URL with curl: `curl -s https://yourdomain.com/products/your-product | grep "application/ld+json"`. If nothing returns, your product schema is missing or injected by JavaScript after load.
2. Check the schema type: grep for `"@type": "Product"` or `"@type": "ProductGroup"`. Both are valid. If you see `ProductGroup`, verify it has at least name, offers, and image at the group level.
3. Verify offers completeness: `price`, `priceCurrency`, and `availability` should all be present. Missing availability is the most common gap in commerce schema.
4. Check your sitemap: `curl -s https://yourdomain.com/sitemap.xml | grep sitemap`. Count how many product sub-sitemaps are listed. Zero means AI agents can't discover your catalogue.
5. Check your Cloudflare WAF: Dashboard → Security → Bots → Bot Fight Mode → configure verified bots policy to allow AI crawlers.
6. Run a Hidden Layer audit: the product_pages category in the result shows per-page schema completeness and discovery status.

Product schema has been best practice for SEO since 2012. In 2026, it's becoming load-bearing infrastructure for AI commerce. The stores that get product recommendations in AI-generated shopping guides are the ones where an agent can fetch a URL, parse a JSON-LD block, and extract price, brand, availability, and reviews in under 100ms. That's the bar.


**Tags:** Product Schema, JSON-LD, E-commerce, Shopify]]></content:encoded>
      <category>Structured Data</category>
      <tag>Product Schema</tag>
      <tag>JSON-LD</tag>
      <tag>E-commerce</tag>
      <tag>Shopify</tag>
    </item>

    <item>
      <title>Cold recall: the 15-point GEO check that tells you if AI knows your brand</title>
      <link>https://hidden-layer-blogs.pages.dev/post/cold-recall</link>
      <guid isPermaLink="true">https://hidden-layer-blogs.pages.dev/post/cold-recall</guid>
      <pubDate>Mon, 11 May 2026 00:00:00 GMT</pubDate>
      <description>We ask a language model — no tools, no search, just training knowledge — to describe your domain. 15 points. The highest-weight single check in the audit. Here&apos;s why it matters and how to move the needle.</description>
      <content:encoded><![CDATA[# Cold recall: the 15-point GEO check that tells you if AI knows your brand

> We ask a language model — no tools, no search, just training knowledge — to describe your domain. 15 points. The highest-weight single check in the audit. Here's why it matters and how to move the needle.

**Category:** GEO Fundamentals | **Date:** 2026-05-11 | **Read:** 8 min

---

Most GEO signals are infrastructure: robots.txt entries, llms.txt files, JSON-LD blocks. You add them, you deploy, you verify. Cold recall is different.

Cold recall measures whether a language model — questioned with no tools, no search, no retrieval context — can accurately describe your brand from its training data alone. It's the 15-point check at the heart of the GEO Presence category and the highest-weight single signal in the Hidden Layer audit.

## What the test actually does

When Hidden Layer audits your domain, it issues a prompt to a language model (llama-3.1-8b via Cloudflare Workers AI). The prompt is: 'What is [your domain]? Describe what it does in 2-3 sentences. If you have no training data about this specific website, reply with exactly: Unknown - not in training data.'

The model runs with no tools enabled, no web search, no retrieval-augmented context. It answers entirely from knowledge absorbed during training. Pass conditions: the model names your brand and describes it in terms consistent with your industry. Fail: the model says 'Unknown', hallucinates a different company entirely, or confuses you with a competitor.

This is not an arbitrary test. It's the closest proxy available for the question 'does this brand exist in the AI consciousness?'

## Why cold recall is worth 15 points

The 15 points reflect a simple reality: cold recall is the GEO signal that can't be faked. You can ship a llms.txt in an afternoon. You can add JSON-LD schema to your homepage in an hour. You cannot retroactively change what's in a model's training weights.

Infrastructure signals tell crawlers how to access your content. Cold recall measures whether the content was worth crawling. A brand with strong cold recall is already present in AI conversations even without optimal infrastructure. A brand that fails cold recall may be fully instrumented — perfect llms.txt, explicit bot permissions, complete schema — but the model has nothing to recall.

In terms of user impact: when someone asks Claude 'recommend me a [your category] company for [your use case]', the answer comes from training data. Not from your llms.txt. Not from your robots.txt. From the model's weights. Cold recall is the signal that measures whether you're in those weights at all.

## The feedback loop: how brands end up in training data

LLM training data isn't curated — it's scraped. Models like GPT-4, Claude, and Llama are trained on web crawls: Common Crawl, C4, the Pile, and proprietary variants. The model's weights reflect the frequency and quality of references to your brand across the web.

The key datasets feeding most public LLMs:

- Common Crawl — a monthly crawl of ~3 billion pages. The backbone of most LLM pretraining sets. Getting crawled here reliably is table stakes.
- Wikipedia — the highest-density authoritative signal in most training sets. A Wikipedia article about your company is the single highest-value action you can take for cold recall.
- Hacker News (via the Algolia HN dataset) — engineering-adjacent brands with HN posts and active comment threads appear disproportionately in coding assistants and developer-focused models.
- Reddit — r/[your category] discussions are massively over-indexed in training data relative to their raw word count. A mentioned brand in 100 Reddit threads outweighs a single press release.
- Academic papers and tech reports — essential for AI/ML brands. Being cited in a paper that describes a dataset or benchmark creates a uniquely durable presence in model weights.
- GitHub READMEs — repositories that mention your brand as a tool, dependency, or comparison are read by code-focused LLMs. Integrations, plugins, and client libraries all contribute.

Models typically cut off training data 6–18 months before release, then may run for 12–24 months before being superseded. Getting into the training data of a current model is not immediately possible — but getting into the training data of the *next* model is the bet you're making today.

## What fails the test (and why)

Several patterns cause brands to fail cold recall despite being legitimate, established companies:

- Too new — the training cutoff predates the company's launch or public presence.
- Geography-specific — a regional brand strong in one country but absent from the English-language web that dominates most training sets.
- B2B only — brands with no consumer presence, no public documentation, and no coverage in general-interest publications that feed training corpora.
- Brand name collision — a name shared with a much larger entity. The model knows the bigger brand and either ignores or confuses the smaller one.
- Content behind login — meaningful coverage exists but is paywalled, behind a corporate intranet, or on platforms not crawled for training.

The common thread: absence from the open, crawlable, attributable web. The model knows what the training crawler could read.

## How to improve cold recall: a priority order

1. Build a Wikipedia article (or claim your stub). Not just a mention — a standalone article about the company meeting Wikipedia notability guidelines. This is the highest-signal single action you can take, and it takes 2–6 weeks from submission to approval if coverage exists.
2. Get cited in at least 3 independent tech or industry publications. Journalist coverage in TechCrunch, Wired, The Verge, or relevant vertical press gets crawled by Common Crawl and surfaces in nearly every training corpus.
3. Ship a Show HN post and participate in the comments. Aim for >100 points. A HN post with engaged discussion will appear in model weights for years.
4. Publish a technical blog post that other developers reference or link to. Inbound links in READMEs and tutorials dramatically amplify corpus presence for developer tools.
5. Get mentioned in Reddit threads in relevant subreddits. These don't need to be your own posts — third-party comparisons and recommendations carry more weight.
6. Open-source something useful. A library or tool with GitHub stars generates organic README mentions, dependency declarations, and tutorial content across the entire developer web.
7. Get an analyst or research mention. Gartner Magic Quadrant, Forrester Wave, or a university study citing your product is a high-authority signal the models weight heavily.

## The timing problem

Training a 70B+ parameter model takes months. Models release with a knowledge cutoff 6–18 months before launch. You're building for the next checkpoint, not the current one.

The practical implication: cold recall improvements take 12–24 months to fully materialise across deployed models. The companies that will have strong cold recall in 2027 are doing the corpus-building work today. Wikipedia article written in early 2026 → crawled by Common Crawl → in the 2026 Q3 training run → deployed in a model in early 2027.

This is the opposite of infrastructure signals, which take effect on the next crawl cycle (days to weeks). Cold recall is a long-game investment. The brands winning AI recommendations in 2027 started building training corpus presence in 2025.

## Run the test on your domain

Hidden Layer's GEO audit includes the cold recall check as the first signal in the GEO Presence category. The result shows the model's raw response — not just pass/fail — so you can read exactly what the model 'knows' about your brand.

A pass shows the model recognising your brand accurately. A fail shows either 'Unknown' or, more informatively, whatever the model believes about you — which may be outdated, incomplete, or confused with a competitor. Both outcomes are actionable: you know exactly what the current model state is, and you have the corpus-building checklist above to improve the next one.


**Tags:** Cold Recall, GEO, LLM Training, Wikipedia]]></content:encoded>
      <category>GEO Fundamentals</category>
      <tag>Cold Recall</tag>
      <tag>GEO</tag>
      <tag>LLM Training</tag>
      <tag>Wikipedia</tag>
    </item>

    <item>
      <title>The render gap: why your website is invisible to AI</title>
      <link>https://hidden-layer-blogs.pages.dev/post/render-gap</link>
      <guid isPermaLink="true">https://hidden-layer-blogs.pages.dev/post/render-gap</guid>
      <pubDate>Fri, 01 May 2026 00:00:00 GMT</pubDate>
      <description>Your homepage loads beautifully in a browser. An AI crawler sees a skeleton. Here&apos;s why — and how to measure the gap for your own domain.</description>
      <content:encoded><![CDATA[# The render gap: why your website is invisible to AI

> Your homepage loads beautifully in a browser. An AI crawler sees a skeleton. Here's why — and how to measure the gap for your own domain.

**Category:** GEO Fundamentals | **Date:** 2026-05-01 | **Read:** 5 min

---

Modern websites are JavaScript-first. The browser downloads a mostly-empty HTML shell, runs hundreds of kilobytes of JS, calls a dozen APIs, then paints the UI. For a human with a fast laptop this is invisible — the page feels instant.

For an AI crawler, it's a wall.

## What AI crawlers actually receive

Most AI training and indexing bots — GPTBot, ClaudeBot, PerplexityBot, Google-Extended — are HTTP crawlers. They fetch a URL, read the response body, and move on. They don't run JavaScript. They don't execute React hydration. They don't wait for API calls to populate content.

So when an AI crawler visits a React or Next.js site that relies on client-side data fetching, it sees the skeleton: a `<div id="__next"></div>` and some script tags. Navigation items rendered by JavaScript? Gone. Product descriptions fetched from an API? Gone. Pricing tables, specifications, structured data injected after mount? Gone.

The AI model trained on this content — or the LLM agent visiting your site to complete a task — works with a stripped, meaningless version of your content.

## Server-side rendering closes the gap

Next.js, Nuxt, SvelteKit, and Remix all support server-side rendering (SSR) or static generation (SSG). When you use getServerSideProps, getStaticProps, or the App Router's async server components, the full HTML — including all content — is in the initial HTTP response. That's what the crawler receives.

The fix isn't to add a special AI-friendly mode. It's to ship HTML that means something without JavaScript. SSR and SSG are already the right architecture for performance, SEO, and accessibility. GEO readiness is another reason to get there.

## How to measure your render gap

Two approaches:

1. curl test: `curl -s -A "ClaudeBot/1.0" https://yourdomain.com | grep -c "<p"`. If the paragraph count is near-zero while your live page has dozens of content blocks, you have a gap.
2. Disable JS in DevTools. Chrome DevTools → Settings → Debugger → Disable JavaScript. Reload. What you see is roughly what AI crawlers see. If the page is blank or barely functional, your render gap is severe.

Hidden Layer's audit checks this automatically — comparing the static HTML response against expected structural markers. A site with a high render-gap score in the AI Visibility category has content locked behind JavaScript that AI agents can't reach.

## What about dynamic content?

Not all dynamic content needs to be in the initial render. Product reviews loaded on scroll, personalised recommendations, live inventory — these are fine as client-side. The content that matters for AI is the canonical information: product specs, prices, descriptions, structured data, navigation, contact information.

If that content is in your initial HTML, AI crawlers can read it. If it's hydrated in later, they can't.


**Tags:** Render Gap, AI Crawlers, GEO]]></content:encoded>
      <category>GEO Fundamentals</category>
      <tag>Render Gap</tag>
      <tag>AI Crawlers</tag>
      <tag>GEO</tag>
    </item>

    <item>
      <title>robots.txt in the AI era: what 10 major brands got wrong</title>
      <link>https://hidden-layer-blogs.pages.dev/post/robots-ai-bots</link>
      <guid isPermaLink="true">https://hidden-layer-blogs.pages.dev/post/robots-ai-bots</guid>
      <pubDate>Tue, 28 Apr 2026 00:00:00 GMT</pubDate>
      <description>robots.txt was designed for Googlebot in 1994. Now 12+ AI bots use it as policy. Most brands haven&apos;t updated their files in years — and it shows.</description>
      <content:encoded><![CDATA[# robots.txt in the AI era: what 10 major brands got wrong

> robots.txt was designed for Googlebot in 1994. Now 12+ AI bots use it as policy. Most brands haven't updated their files in years — and it shows.

**Category:** Bot Policy | **Date:** 2026-04-28 | **Read:** 6 min

---

The Robots Exclusion Protocol was proposed by Martijn Koster in 1994 to let webmasters tell search engine crawlers which pages to skip. For thirty years, it worked fine. Google, Bing, Yahoo — a handful of well-behaved crawlers that most teams understood.

Then 2023 happened. OpenAI launched GPTBot. Anthropic published ClaudeBot documentation. Perplexity, Cohere, Meta, Apple, ByteDance — each with their own crawler UA string. Suddenly robots.txt became AI policy, and most brands had no policy at all.

## What the major bots actually check

Each AI crawler looks for its own user-agent string in robots.txt. GPTBot looks for `User-agent: GPTBot`. ClaudeBot looks for `User-agent: ClaudeBot`. If neither is present, most crawlers fall back to the `User-agent: *` rule — which for most sites is `Allow: /`.

This means an absence of AI bot rules isn't neutral. On most sites, it means all AI crawlers are implicitly allowed. That may be your intent — but it should be a conscious decision, not a default.

## The 403 trap

Some brands use Cloudflare's Bot Fight Mode or similar WAF rules to block non-browser traffic at the edge. When an AI crawler hits the robots.txt endpoint and receives a 403, it has no way to distinguish "this file doesn't exist" from "this domain has a CDN that blocks all bots." The practical result is equivalent to a blanket Disallow: / — the crawler treats the domain as inaccessible.

If you're using edge-level bot blocking, verify that your CDN rules pass through well-known AI crawler UAs. Cloudflare's verified bot list now includes GPTBot, ClaudeBot, and PerplexityBot — enabling "Allow verified bots" in the dashboard restores access.

## Training vs. browsing bots: different rules, same file

Not all AI bots are the same. GPTBot and ClaudeBot are training crawlers — they download content for model training. OAI-SearchBot, Claude-SearchBot, and PerplexityBot are retrieval crawlers — they fetch live content when a user asks the LLM to browse the web. ChatGPT-User and Claude-User are on-demand fetchers — triggered by a user asking the AI to read a specific URL.

You may want different policies for each type. A brand that doesn't want AI training on its content might still want retrieval bots to send the AI tool's users to their pages. robots.txt supports this with separate User-agent blocks.

```
User-agent: GPTBot
Disallow: /

User-agent: ClaudeBot
Disallow: /

User-agent: OAI-SearchBot
Allow: /

User-agent: Claude-SearchBot
Allow: /
```

## Content-Signals: the emerging extension

The Content-Signals draft adds structured directives to robots.txt as comments. This provides more granular intent than a binary Allow/Disallow. It's not a formal standard yet, but adding the comment costs nothing and signals intent to crawlers that check for it.

```
# Content-Signal: allow-training allow-search disallow-training-commercial
```

## Where most brands fail

Running Hidden Layer audits on 50+ domains reveals a consistent pattern: most brands have robots.txt files that predate AI crawlers entirely. They block Googlebot-Image and Bing crawlers with precision — and have no mention of GPTBot, ClaudeBot, or any other AI UA. Policy by omission.

The fix takes 10 minutes: add explicit User-agent blocks for each AI crawler with the Allow or Disallow that reflects your actual intent. Write it like policy, because that's what it is.


**Tags:** robots.txt, AI Bots, Bot Policy]]></content:encoded>
      <category>Bot Policy</category>
      <tag>robots.txt</tag>
      <tag>AI Bots</tag>
      <tag>Bot Policy</tag>
    </item>

    <item>
      <title>llms.txt: a year in, what actually works</title>
      <link>https://hidden-layer-blogs.pages.dev/post/llms-txt-guide</link>
      <guid isPermaLink="true">https://hidden-layer-blogs.pages.dev/post/llms-txt-guide</guid>
      <pubDate>Wed, 22 Apr 2026 00:00:00 GMT</pubDate>
      <description>Shopify has one. Samsung has one. Anthropic and OpenAI don&apos;t. A practical look at what llms.txt does, what format AI models actually process, and whether it&apos;s worth your time.</description>
      <content:encoded><![CDATA[# llms.txt: a year in, what actually works

> Shopify has one. Samsung has one. Anthropic and OpenAI don't. A practical look at what llms.txt does, what format AI models actually process, and whether it's worth your time.

**Category:** Standards | **Date:** 2026-04-22 | **Read:** 7 min

---

In September 2023, Jeremy Howard proposed llms.txt: a markdown file at /llms.txt giving AI systems a curated overview of your site's content, purpose, and key pages. The idea was simple — the same way robots.txt tells crawlers what to avoid, llms.txt tells LLMs what to know.

A year in, adoption is uneven, format is inconsistent, and the spec has evolved. Here's what we know.

## What the spec actually says

The canonical spec at llmstxt.org defines a minimal structure:

- A top-level heading (# Site Name) with a brief description as blockquote
- An optional ## Description section with detailed context
- Optional sections with markdown links to key pages
- An optional /llms-full.txt companion with extended content

The file should be plain markdown, UTF-8, served at /llms.txt with Content-Type: text/plain. CORS headers are needed if AI tools fetch it cross-origin: Access-Control-Allow-Origin: *.

## Who has adopted it (as of May 2026)

Shopify — Yes. 860 bytes. Clean structure with product/partner/developer sections. One of the earliest enterprise adopters.

Samsung — Yes. 4KB. Explicit AI bot rules in robots.txt plus a structured llms.txt with product family sections.

Anthropic — No. Despite being the company behind Claude, anthropic.com has no llms.txt as of this writing.

OpenAI — No. openai.com has no llms.txt either. Neither company dogfoods the signal their crawlers respect.

## Does it actually affect LLM outputs?

This is the honest question. The answer is: sometimes, for retrieval-based queries, yes.

When a user asks an LLM tool like Perplexity or Claude's web search to "explain what [brand] does," the tool fetches the site. If llms.txt is present and well-structured, it's often what gets retrieved and parsed — it's small, machine-readable, and explicitly curated. The LLM answer is more accurate than if it had to parse the homepage's marketing copy.

For training-based knowledge (what the model knows without looking anything up), llms.txt has no effect. The model was trained on whatever content was crawled before cutoff.

## What format works best

Based on testing with Claude, GPT-4o, and Perplexity:

- Lead with a one-sentence description as the first paragraph after the H1. This is what gets extracted as a summary.
- Use H2 sections with meaningful names — "Products", "Pricing", "Developer docs" — not "Section 1".
- Link to your most important pages with descriptive anchor text. The link text matters more than the URL.
- Keep it under 5KB. The point is curation, not documentation. If you need more, use llms-full.txt.
- Update it quarterly. A stale llms.txt pointing to deprecated pages is worse than none.

## Is it worth it?

For most sites: yes, because it takes 30 minutes once and the upside is durable. The bar for AI discoverability is low enough that a well-structured llms.txt is genuinely differentiating.

For B2B SaaS: critical. Your buyers are using LLMs to research vendors. A good llms.txt that explains your ICP, pricing model, and integration story directly influences how Claude or GPT describes you to a buyer who asks "what's the best tool for X?"


**Tags:** llms.txt, AI Discovery, Standards]]></content:encoded>
      <category>Standards</category>
      <tag>llms.txt</tag>
      <tag>AI Discovery</tag>
      <tag>Standards</tag>
    </item>

    <item>
      <title>The 12 AI bots crawling your site right now</title>
      <link>https://hidden-layer-blogs.pages.dev/post/ai-bot-registry</link>
      <guid isPermaLink="true">https://hidden-layer-blogs.pages.dev/post/ai-bot-registry</guid>
      <pubDate>Wed, 08 Apr 2026 00:00:00 GMT</pubDate>
      <description>A field guide to every major AI crawler: what company runs it, what it does with your content, whether it respects robots.txt, and what UA string to put in your rules.</description>
      <content:encoded><![CDATA[# The 12 AI bots crawling your site right now

> A field guide to every major AI crawler: what company runs it, what it does with your content, whether it respects robots.txt, and what UA string to put in your rules.

**Category:** Bot Registry | **Date:** 2026-04-08 | **Read:** 8 min

---

There are twelve AI crawlers that matter right now. Some train models. Some power live search. Some fetch content on-demand when a user asks an AI tool to read a URL. All of them use your robots.txt as policy — if you have one.

## Training crawlers

Training crawlers download content at scale for use in model training datasets. They're not tied to live user queries — they run on schedules, build large corpora, and the content they collect shows up in model behaviour months later.

### GPTBot — OpenAI

UA: Mozilla/5.0 AppleWebKit/537.36 (compatible; GPTBot/1.2; +https://openai.com/gptbot)

OpenAI's primary training crawler. Respects robots.txt. Blocking GPTBot means your content doesn't appear in future GPT training runs — it doesn't affect existing model knowledge or live ChatGPT browsing.

### ClaudeBot — Anthropic

UA: Mozilla/5.0 AppleWebKit/537.36 (compatible; ClaudeBot/1.0; +claudebot@anthropic.com)

Anthropic's training crawler. Respects robots.txt. Like GPTBot, blocking it affects future training, not current model knowledge.

### Google-Extended — Google

Separate from Googlebot (search indexing). Controls whether your content trains Bard/Gemini. Can be blocked independently without affecting Google Search.

### Applebot-Extended — Apple

Apple's AI training crawler, used for training Apple Intelligence models. Distinct from Applebot (used for Spotlight and Siri search results).

### CCBot — Common Crawl

Non-profit crawler that publishes a public web archive. Many open-source models train on Common Crawl data. Frequently blocked by brands concerned about AI training.

### Meta-ExternalAgent — Meta

Used for training Meta's Llama and other AI models. Respects robots.txt.

### Bytespider — ByteDance

ByteDance's crawler, used for TikTok, Doubao, and other AI products. Historically controversial for its robots.txt compliance. Hidden Layer recommends blocking by default unless you have specific reason to allow ByteDance AI training.

## Retrieval/search crawlers

These bots fetch content in response to live user queries — when you ask Perplexity a question, it sends PerplexityBot to retrieve current information.

### OAI-SearchBot — OpenAI

Powers ChatGPT's web browsing and SearchGPT. This is the bot you want to allow even if you block GPTBot — it sends users to your site and appears as a referral source in analytics.

### Claude-SearchBot — Anthropic

Powers Claude's web search feature. Same commercial reasoning as OAI-SearchBot — this is traffic and discovery, not training.

### PerplexityBot — Perplexity

Powers Perplexity's real-time answers. Blocking PerplexityBot means your content doesn't appear in Perplexity answers, which for some industries is now a meaningful traffic source.

## On-demand fetch bots

### ChatGPT-User — OpenAI

Used when a ChatGPT user shares a URL in conversation. Appears as a session visit, not a continuous crawl.

### Claude-User — Anthropic

When a user pastes a URL and asks Claude to read it, this is the UA string used.

## The robots.txt template

For most brands, the recommended starting point:

```
# Training crawlers — allow by default
User-agent: GPTBot
Allow: /

User-agent: ClaudeBot
Allow: /

User-agent: Google-Extended
Allow: /

User-agent: Applebot-Extended
Allow: /

# Training crawlers — common to block
User-agent: CCBot
Disallow: /

User-agent: Bytespider
Disallow: /

# Retrieval bots — almost always allow
User-agent: OAI-SearchBot
Allow: /

User-agent: Claude-SearchBot
Allow: /

User-agent: PerplexityBot
Allow: /

# On-demand fetch — almost always allow
User-agent: ChatGPT-User
Allow: /

User-agent: Claude-User
Allow: /
```

This makes your intent explicit rather than relying on the User-agent: * fallback. Update it when new AI crawlers launch — this list will grow.


**Tags:** AI Bots, Bot Registry, robots.txt]]></content:encoded>
      <category>Bot Registry</category>
      <tag>AI Bots</tag>
      <tag>Bot Registry</tag>
      <tag>robots.txt</tag>
    </item>
  </channel>
</rss>