You ran Lighthouse. Everything is green. Performance, accessibility, best practices, SEO — all in the nineties or above. You shipped it.
Then an AI agent tries to book a reservation on your site and fails silently.
Those two things are not contradictory. They are the expected outcome when you optimize for one kind of readiness and ignore another.
What Lighthouse Actually Measures
Lighthouse is a static analysis tool. It loads a page, inspects what is declared, and scores what it finds. It checks whether your images have alt text, whether your tap targets are large enough, whether your HTML is well-formed, whether your server responds quickly.
All of that is genuinely useful. None of it tells you whether an AI agent can complete a purchase flow on your site.
Lighthouse has no concept of multi-step task completion. It does not simulate an agent navigating from a product page to a cart to checkout to confirmation. It does not know what happens when a form has ambiguous labels that a human can visually interpret but an LLM cannot map to an intent. It does not catch the modal that fires on step three and traps an agent in a loop.
Lighthouse measures what is declared. Agents care about what happens.
The Gap Between Declaration and Execution
Static readiness checks — Lighthouse, structured data validators, sitemap linters — all operate on the same principle: they read what your site says about itself and report whether that declaration is well-formed.
This is the same gap that exists between a robots.txt file and actual crawl behavior, between a schema.org annotation and a model correctly extracting a price, between a sitemap entry and a page an agent can actually act on.
Your structured data can be perfectly valid and still describe a flow that no agent can complete, because the flow itself was never tested against an agent.
What Agents Actually Need
AI agents operating on the web are not reading your Lighthouse report. They are attempting tasks. Buy this. Book that. Find the cancellation policy. Add to cart and check out.
For those tasks to succeed, several things have to be true that no static tool can verify:
- The navigation from intent to completion has to be unambiguous enough for a model to follow
- Forms have to be labeled in ways that map to natural language descriptions of what they do
- Error states have to be recoverable, not just present
- The flow has to work end to end, not just page by page
- The flow has to work across different models, because a capable model navigating confidently does not mean a less capable model can do the same thing
That last point matters more than most teams expect. What a premium model handles fine can still trip up a cheaper one. Testing against a single model gives you a single data point. It does not give you a picture of your site's actual agent-readiness across the range of models your users might be running.
Agent-Readiness Is a Regression Problem, Not a Score Problem
Here is the other thing static tools miss: agent-readiness is not a property you establish once and keep forever. Every deploy is a potential regression.
A developer refactors a checkout component. A designer updates the booking modal. A product manager adds a required field to a form. Any of these can break a flow that was working before, and none of them will show up in your next Lighthouse run.
This means treating agent-readiness like a score — something you check periodically and report on — is the wrong mental model. It is a regression surface. You need a baseline, and you need every deploy compared against that baseline, so regressions are caught before agents hit them in production.
CI pipelines already do this for unit tests, integration tests, and visual regression tests. Agent-readiness needs the same treatment.
What "Scores Tell You What's Declared" Actually Means in Practice
Imagine two sites. Site A has a Lighthouse score in the nineties, clean structured data, a valid sitemap, and correct robots.txt directives. Site B has the same, plus: real AI agents have completed actual purchase and booking flows against it, every deploy is compared against a CI baseline, and the flows have been tested across ten different LLM agents.
Site A knows what it declares. Site B knows what happens.
For human visitors, Site A is probably fine. For AI agents trying to complete tasks, Site A is an unknown. The Lighthouse score tells you nothing about the execution layer that agents depend on.
The Practical Implication
If your site needs to work for AI agents — and increasingly, it does — then your readiness testing needs to include what static tools structurally cannot provide: real agents completing real tasks, regression detection across deploys, and coverage across the range of models that might be operating on your behalf.
That is not a criticism of Lighthouse. Lighthouse is the right tool for what it measures. It is just not the right tool for this.
Scovant runs real AI agents against your site — simulations, CI regressions, and multi-model testing across ten different LLM agents. If you want to know what actually happens when an agent tries to use your site, not just what your site declares, that is where to start.
See how scoring works, check the docs, or look at pricing.