Agentic Search Is Here. Your CMS Decides If You Survive It.

The shift nobody warned you about

In the last 30 days, three quiet releases changed what a website needs to be.

Lighthouse 13.3 — the audit tool built into every Chrome browser and every PageSpeed Insights report — moved agentic-browsing audits from experimental into its default configuration. Chrome 149 opened the origin trial for WebMCP, an API that lets AI agents call your forms as if they were function endpoints. Google's I/O 2026 announcements added Information Agents to AI Mode, which now serves over 1 billion monthly users.

These aren't roadmap items. They shipped. And the average score across 11 real customer sites tested against the new audits: 17 out of 100.

Nobody has shipped this yet. Which means the next 12 months are an inflection point. Businesses whose websites are agent-ready will get cited inside AI responses, invoked by autonomous agents, and surfaced in the new agentic search flows. Those that aren't will quietly become invisible to a layer of traffic that didn't exist two years ago.

The question this article answers: what specifically decides whether your website passes or fails this new audit? And spoiler — it isn't your design, your copy, or your SEO meta tags. It's your CMS architecture.

What "agent-ready" actually means

When Lighthouse audits your site for agentic browsing, it checks a specific surface:

Is there a /llms.txt file at your domain root? A plain-text Markdown file that gives AI agents a curated reading list of your site. Without it, agents pick URLs at random.

Are your forms annotated with tool descriptions? WebMCP lets you mark forms (or programmatically register tools) with semantic descriptions of what they do, so an AI agent can fill them out autonomously.

Does your accessibility tree have proper structure? Roles, parent-child relationships, programmatic names — the accessibility tree is the primary data model for agents reading your site.

Is your Cumulative Layout Shift (CLS) low enough? Agents need stable DOM positions to click reliably. A site that shifts after load doesn't just frustrate users — it breaks autonomous interaction.

Is there a /.well-known/mcp.json manifest? Emerging convention. Declares which actions your site exposes to agents.

These aren't five disconnected fixes. They're all symptoms of one underlying question: does your website have a machine-readable model of itself, or is it just HTML?

Why most websites will fail this audit

The traditional web stack — and most of the platforms agencies still use — was built for one consumer: a human with a browser. Content lives as HTML. Forms exist as form tags. Page structure is implicit, derived from headings and navigation. The CMS underneath is usually a database of pre-rendered pages or blog posts as opaque content blobs.

That architecture works fine when the consumer is a person.

It breaks when the consumer is an agent. An AI agent doesn't read your hero section the way a human does. It needs the data under the hero section. It doesn't browse your blog the way a human does. It needs an index of which posts exist and what they're about. It doesn't fill out your contact form by inferring what fields mean from labels. It needs a programmatic description of what the form does.

Adding these things to a traditional CMS is possible. It's also expensive. You're hand-writing a /llms.txt file. You're manually annotating every form. You're regenerating those artifacts every time content changes. You're maintaining a parallel infrastructure of "agent-readable" metadata that has to stay in sync with the "human-readable" website.

This is why the industry average is 17/100. Not because the work is hard. Because doing it on top of the wrong substrate is unsustainable.

The structured-content thesis

There's a different way to build a website. It's been around for years, mostly used by enterprise teams that needed multi-channel content distribution. The premise is simple: instead of storing your content as HTML, store it as typed structured data in a headless CMS, and render it however each consumer needs.

Sanity is the cleanest implementation of this pattern. Every field in a Sanity document has a name, a type, and a schema. A blog post isn't a string of HTML — it's a post document with title, slug, excerpt, body (as Portable Text), author (as a typed reference), categories (as references), publishedAt, seo (as a structured object), and so on. You query that data with GROQ, Sanity's purpose-built query language, and get exactly the shape you ask for.

What makes this matter for the agentic web: the data inside your CMS is already in the shape an agent needs. You don't have to build a parallel agent-readable infrastructure. You just expose what's already there, in the right wrappers.

Specifically:

Your /llms.txt becomes a Next.js Route Handler that queries Sanity with GROQ and returns formatted Markdown.

Your WebMCP manifest at /.well-known/mcp.json is generated from your Sanity schema, with tool descriptions pulled from field descriptions.

Your blog post index, contact form schema, product catalog — all already typed, all already queryable, all already structured.

This is what "the substrate question" means. The CMS isn't a tactical decision about who can edit text. It's a strategic decision about whether your website can be consumed by agents at all.

The auto-update flow (with the actual code)

Here's how this works on the ShapeShifters stack — Sanity as the CMS, Next.js as the framework. The whole pattern fits in three files.

1. A Next.js Route Handler at /app/llms.txt/route.ts:

import { client } from '@/sanity/lib/client'

export async function GET() {
const posts = await client.fetch(`
*[_type == "post" && defined(slug.current)]
| order(publishedAt desc) {
title,
"slug": slug.current,
"url": "https://shapeshifters.dev/blog/" + slug.current,
excerpt
}
`)

const markdown = `# ShapeShifters

> Custom-developed websites with intelligence built in.

## Blog Posts

${posts.map((p) =>
`- [${p.title}](${p.url}): ${p.excerpt}`
).join('\n')}
`

return new Response(markdown, {
headers: { 'Content-Type': 'text/plain; charset=utf-8' },
})
}

That's it. A GROQ query that pulls your published content, formatted as Markdown, served as plain text at /llms.txt. The Next.js framework handles caching automatically.

2. A Sanity webhook that triggers regeneration on every content change:

In your Sanity project at manage.sanity.io, create a webhook with the GROQ filter _type == "post". Point it at a revalidation endpoint on your Next.js app.

3. A revalidation endpoint at /app/api/revalidate-llms/route.ts:

import { revalidatePath } from 'next/cache'

export async function POST(req: Request) {
const secret = req.headers.get('x-sanity-webhook-secret')
if (secret !== process.env.SANITY_WEBHOOK_SECRET) {
return new Response('Unauthorized', { status: 401 })
}

revalidatePath('/llms.txt')
return new Response('OK')
}

Whenever a blog post is published, updated, or deleted in Sanity, the webhook fires, the revalidation endpoint runs, and /llms.txt is regenerated. AI agents crawling your site get the current map within seconds.

The same pattern handles the WebMCP manifest at /.well-known/mcp.json — except instead of generating Markdown, it generates JSON describing the actions your site exposes (search, contact, booking) with their input schemas and descriptions.

What this means for Dubai businesses specifically

The agentic search shift hits hardest in markets where buyers do extensive research before transacting. Dubai's premium economy — real estate, medical, hospitality, interior design, financial services — is exactly that kind of market.

When a UHNWI buyer asks AI Mode "longevity clinics in Dubai for executives", the response will cite specific clinics. Being cited requires the clinic's website to be agent-readable. When an Information Agent monitors property launches on behalf of a buyer, it interacts with listings programmatically. That interaction requires WebMCP-style tool descriptions.

The agencies serving these markets have a choice in the next 12 months: rebuild their clients' websites on a substrate that makes agent-readiness automatic, or hand-patch agent infrastructure onto existing sites for years. The first path is cheaper to maintain. The second compounds technical debt every quarter.

For ShapeShifters' clients running on Sanity + Next.js, the agentic upgrade is a Route Handler, a webhook, and a manifest file. Two days of work. For clients on traditional CMS architectures, the upgrade is either a parallel maintenance burden or a migration.

How to start

If you're a business owner reading this:

1. Run "npx lighthouse https://yoursite.com --preset=experimental" against your homepage. Read the agentic browsing audit results. Don't be surprised if you score under 20.

2. Check if you have /llms.txt at your domain. If you do, validate it parses correctly against the llmstxt.org reference parser. If you don't, that's the lowest-hanging fix.

3. Audit your CMS. If your content lives as HTML inside a database, ask your team: how would we generate a machine-readable index of every content type, on demand, with live regeneration? If the answer involves a custom script or "we'd have to rebuild parts of the site," your substrate is the wrong shape.

If you're a Dubai business operating in real estate, medical, hospitality, financial services, or any other category where buyers research extensively before transacting — the question of agent-readiness will become a competitive lever this year. The agencies that build on the right substrate will deliver it as a default. The agencies that don't will sell it as a six-figure rebuild.

We're running Lighthouse 13.3 against the ShapeShifters portfolio this week — including this site, AURUM Longevity Institute, and others. The baselines and the exact code that fixes them will publish in the next post. If you want to be on the call list when we open consultations on agent-readiness audits, drop us a note at shapeshifters.dev/contact.

Continue reading

→ What is an agentic web platform?

→ AI Changed Your Business. You Just Haven't Noticed Yet

→ What Is a Headless CMS? Why Sanity Powers the Best Modern Websites