JavaScript Rendering Is a Search Problem — and an Agent Problem
Search engines and AI agents need readable HTML, not JavaScript-rendered empty shells.

JavaScript rendering is a search problem and an agent problem because a page that works in a browser can be unreadable outside it. Deliver meaningful HTML that search engines, AI crawlers, and autonomous agents can read, then give that content enough structure for each to understand and use it.
Why JavaScript rendering was always a legibility problem, not just a speed problem
The familiar two-wave indexing story begins with what the server sends. In the first wave, Googlebot fetches raw HTML before JavaScript runs. If the page inserts its primary content through client-side code, that response may contain little more than <div id="app"></div>. The page exists for a browser after execution. At the point of the initial fetch, however, its content is missing.
The second wave sends the page to Google’s Web Rendering Service, or WRS, which runs JavaScript in an evergreen Chromium engine and produces the final DOM. This is a resource-allocation bottleneck. Authority and crawl priority shape the queue, so lower-priority pages can wait hours to weeks while high-authority pages get attention quickly. Yet waiting is only one failure mode. Googlebot does not click, hover, or scroll, so content that requires those actions remains inaccessible even when rendering succeeds.
What, then, is the underlying problem? A site has made reading depend on executing its application, and sometimes on interacting with it. Google has infrastructure that can bridge part of that gap, which makes missing content look like a delay. But that bridge is not part of the page itself. The same dependency makes the page illegible to any reader that lacks a JavaScript engine.
Which crawlers actually render JavaScript — and which see the empty shell
Gemini is an important exception to the AI crawler divide. Google’s Martin Splitt publicly described its use of WRS in May 2025, placing it among the few AI crawlers with JavaScript rendering capability, together with Apple’s crawler. Googlebot likewise uses a headless browser engine to read the rendered DOM. These systems can reach beyond the initial HTML response. Their capabilities should not be assumed for other readers.
GPTBot, ClaudeBot, and PerplexityBot download the initial HTML and stop there, so client-rendered content is absent from the layer they read. Vercel and MERJ’s analysis of a large sample of GPTBot fetches found zero evidence of JavaScript execution. That finding concerns the response.
The split is therefore more than a difference in indexing speed. A single-page application can have a top Google ranking while ChatGPT, Claude, and Perplexity all fail to see its primary content through these crawlers. Google’s rendering machinery can make the page legible to search without changing what the server delivers to anyone else.
What the AI citation gap means for brand visibility in generative answers
Generative Engine Optimization, or GEO, aims to get a brand selected, cited, and surfaced inside an AI-generated answer. Can the system read enough of the brand’s content to use it as a source? If its crawler receives an empty shell, the page cannot earn a citation through that content.
Even among readable sources, visibility is uneven. Global household names appear in most AI answers on the subject, established mid-market brands appear in under half, and niche or small brands appear in only a few. Platform differences widen those gaps. The same brand can receive citation volumes that differ by orders of magnitude between Grok and Claude, while strong visibility on Perplexity can coexist with near-invisibility on Gemini. There is no single AI audience with one shared view of a brand.
Rendering blindness hurts a page in a different way from weak authority or content that is poorly organized. Those weaknesses still leave the system something to judge, but when the content is missing, it has nothing to judge. Improving the wording of a client-rendered page cannot help a crawler that never receives the words. Clean HTML delivery is therefore a prerequisite for GEO work, alongside the relevance and authority that win citations.
Why the agent problem is sharper than the crawler problem
A crawler can collect content for later use. An autonomous agent needs to read enough now to decide whether it can take an action. Such an agent typically fetches a URL programmatically, without a browser, and sees the raw HTTP response. A JavaScript bundle is not a pricing table. If the needed information exists only after rendering, the agent has no actionable content from that fetch.
Consider a purchasing agent that is reading a product’s pricing page. If the response contains only an app shell, the agent cannot use the missing prices to assess the offer and may fail silently or move to a competitor’s readable page. A research agent that fetches API documentation runs into the same barrier. The documentation may be complete for a human visitor, but completeness in the browser does not make it available to the agent.
Could the agent simply render the page later? That is the wrong assumption for a single-fetch workflow that does not retry with a headless browser. Google’s eventual indexing and an agent’s immediate access are different standards. Without a server-side fallback, the agent gets the same empty response each time and stays shut out however long it waits. Semantic HTML, clear headings, and machine-readable signals also help the agent make sense of what it gets, but they can only help with primary content that reaches it.
The phantom-authority experiment as proof that the human web and the agent web are splitting
Sascha Deforth, founder of GEO consulting firm TrueSource, demonstrated the reverse of the empty-shell problem in the Phantom Authority experiment. In April 2026, a completely blank webpage with zero visible text and zero images was Perplexity AI’s number-one cited source within days of going live. Human-visible content was absent, but machine-readable content was not. The experiment’s “Seven-Layer Ghost Stack” included JSON-LD, llms.txt, reasoning.json, and ai-manifest.json, with Ed25519 cryptographic signatures intended to let AI systems verify entity claims. Those layers gave the AI system the authority signals it recognized.
Google marked the page as spam while Perplexity cited it first, so the same URL got opposite verdicts on the same day. The contrast exposes a split in what systems read and reward. It does not show that ordinary visible content has become unnecessary.
A 2026 empirical study at arxiv.org/abs/2606.20065 found that about 78% of AI source citations went to corporate websites. Among non-corporate sources, video on YouTube was the most-cited format, ahead of Reddit, editorial media, and Wikipedia. A brand’s own readable website is therefore substantial ground to control. Avoid replicating Deforth’s method, which violates Google guidelines, and recognize that investing in only one layer can leave another reader with a very different page.
What the rendering hierarchy actually means for a team choosing a framework today
For a team choosing a rendering approach, the practical rule is to use static site generation or server-side rendering for public-facing content. Static site generation, or SSG, builds HTML at deploy time and serves it as flat files. It is the fastest, most crawl-friendly option for content that does not change per request. The first fetch contains the complete content. A crawler or an agent can read it without running the application.
When content has to be built for each request, server-side rendering, or SSR, is the next option. The server makes the full HTML before client-side JavaScript runs, and Next.js, Nuxt, and Astro make this a standard way to build a page. Google’s first wave receives the primary content without depending on WRS for that content’s indexing. Agents receive a readable response too. The choice between SSG and SSR follows how the content changes.
Dynamic rendering sits below those options because it treats access as a special case. It detects crawler User-Agents and gives bots pre-rendered HTML while serving the application to users. Google describes it as an interim workaround. It adds infrastructure complexity and misses agents that do not identify themselves with a known bot User-Agent. Client-side rendering still fits authenticated dashboards and internal tools that have no need to be read through search or without a browser.
Even SSR needs a check of its delivered output. Hydration errors can leave Googlebot with only part of the content, so raw page source is a more reliable check than the DOM shown in DevTools. Navigation needs the same attention. Standard anchor tags with real href attributes let crawlers and agents find pages within the site, but <div onclick> navigation does not.
Structured data and machine-readable layers as the second half of the fix
Once HTML delivery is reliable, the next task is to make the page’s meaning explicit. JSON-LD should be in the server-rendered response, available before JavaScript runs. Otherwise, Google has to wait for rendering, and non-rendering crawlers never get it at all. The same is true of canonical tags, hreflang attributes, and meta descriptions that are added after load.
Does adding schema reliably increase AI citations? The evidence in the notes does not support that simple claim. A matched test of pages that added JSON-LD showed no measurable citation lift, whereas the Phantom Authority experiment used a much broader machine-readable stack. Those outcomes do not isolate the value of any one layer. A minimal schema addition cannot be assumed to replace semantic depth in the content itself.
For agents, structure also serves a purpose beyond citation. Clear heading hierarchies and semantic HTML help identify what a page is about and whether it contains information needed for an action. An llms.txt file can provide another low-cost orientation signal, but it does not replace substantive content. Bing’s citation-share data points to topical relevance and content position as reproducible levers for AI citation.
Measuring whether your fixes are actually working across search, AI answers, and agents
Raw page source, which is available through Ctrl+U, shows whether the content that matters is there before JavaScript runs. Google Search Console’s URL Inspection tool then shows what Googlebot gets. A page can deliver the right initial HTML yet still require investigation of how Google handles it.
AI answer visibility needs its own measurement. Share of Model, or SoM, is brand mentions divided by total AI answers in a tracked query set. Tracking it across ChatGPT, Claude, Gemini, and Perplexity requires purpose-built measurement because no single native tool covers all four. Platform differences make a combined impression inadequate. A rendering fix can let systems read a page without getting it cited more often on all of them right away.
Agent access calls for the simplest test of all. A team should fetch the URL without a browser, using a curl request or an HTTP GET from a script, and inspect the response for the information an agent would need. That could be pricing, specifications, documentation, or key claims. If those are missing, the agent still lacks what it needs even if the page works in a browser. Search inspection, answer tracking, and direct fetching answer different questions, and only the last shows whether an agent can read what it needs right now.


