We made navaigate.dev agent-native, and scored 71.

Your website is invisible to AI agents.

Not broken. Not slow. Invisible. An agent hitting your site today can't discover what you do, can't call your services programmatically, and can't hand you a qualified lead without a human in the loop. For most businesses that gap is an annoyance. For any company selling AI services, it's a credibility problem.

We found this out the hard way. We ran navaigate.dev through Cloudflare's agent-readiness scanner and scored 21 out of 100, Level 1. A site that helps enterprises adopt AI couldn't be found by an AI. That result was uncomfortable enough to fix immediately.

Here's what we did, why it matters, and how you can run the same playbook on your own site.

What does "agent-ready" actually mean?

Search-engine SEO taught us to optimise for crawlers. Agent-readiness is a different problem. A crawler indexes text. An agent reasons about capabilities, calls APIs, reads structured metadata, and decides in real time whether your site is worth interacting with.

Cloudflare's scanner checks five dimensions: whether agents can discover your site and understand its purpose, whether your content is machine-readable in formats agents prefer, whether you expose authenticated or open endpoints they can call, whether you signal what actions are available, and whether you honour well-known discovery conventions. Score well across all five and you reach Level 5, the site functions as a proper node in the agentic web.

Most sites score somewhere between Level 1 and Level 2. They have HTML, maybe a sitemap, and nothing else an agent can use.

The three layers we built

We thought of the work in three layers: Discovery, Content, and Action. Each layer builds on the one before it.

Discovery

The first problem is letting agents find you and understand your intent before they read a single page. We added a robots.txt block for AI crawlers (User-agent: GPTBot, User-agent: ClaudeBot) with explicit Allow directives and a content signal in our response headers. We published an llms.txt file at the root, a structured plain-text declaration of who we are, what we do, and where our key resources live. We added RFC 8288 Link headers pointing agents to our machine-readable endpoints. We registered a /.well-known/api-catalog entry so any agent following the discovery spec can enumerate our capabilities without guessing.

These changes cost nothing to serve and they take the guesswork out of the agent's first pass.

Content

Discovery gets an agent through the door. Content determines whether it understands what to do next.

We enabled markdown content negotiation, when a request arrives with Accept: text/markdown, the server returns clean markdown rather than HTML. Agents parse markdown reliably; they parse navigation-heavy HTML poorly. We published an auth.md file at /.well-known/auth.md describing our authentication model (where it exists) so agents don't waste round-trips probing for it. We built an Agent Skills index, a single page listing every capability the site exposes in a structured format, analogous to what a human-facing sitemap does for Google.

Action

Discovery and Content are passive. The Action layer is where the site stops being a document and starts being a participant.

We published a Model Context Protocol (MCP) card at a well-known path, backed by a real endpoint. We published an Agent-to-Agent (A2A) card describing how another agent can hand off work to our services. We wired up WebMCP so that an agent can, without human involvement, discover our workshop offering, check availability, and initiate a booking at navaigate.dev/#contact. The endpoint isn't a stub, it does something.

That last point matters more than any of the others.

Why we didn't fake the endpoints

There is a tempting shortcut: publish all the metadata, all the cards, all the discovery files, but point them at endpoints that return 200 with an empty body. Your score goes up. Nothing works.

We didn't do that, and we won't recommend that approach to any client. Here's the reasoning.

Agent-readiness scores are a leading indicator, not the end goal. The goal is that an agent, whether it's a customer's AI assistant, a partner's orchestration layer, or an autonomous research agent, can actually do something useful when it arrives at your site. A fake endpoint fails the first real call and poisons trust in your domain for every subsequent agent interaction.

Every endpoint we claim, we run. If we can't run it yet, we don't claim it. Ship real capability, then describe it, not the other way around.

This is the same standard we apply when we help enterprise teams build AI-native products through our Orient, Experiment, Operationalise methodology.

Results across our three sites

Starting score for navaigate.dev: 21, Level 1.

After one focused sprint across the Discovery, Content, and Action layers:

• navaigate.dev, 71 / Level 5
• cohort01.com, Level 5 (built agent-native from the start on the second attempt)
• bluplai.com, Level 5

Level 5 means all five scanner dimensions pass. Agents can find the site, understand its capabilities, read structured content, call real endpoints, and initiate actions. The sites now participate in the agentic web rather than sitting passively in it.

The jump from 21 to 71 on navaigate.dev came from three files, four response headers, two endpoint cards, and one honest conversation about what we were actually ready to expose.

How to make your own site agent-native

We open-sourced the entire playbook as a Claude Code skill: github.com/skyremote/agent-ready-website (MIT licence).

The skill runs an audit against Cloudflare's scanner, identifies exactly which of the five dimensions you're failing, generates the files and headers you need, and wires up the endpoint stubs in whatever stack you're running. It takes a green-field site to Level 5 in one session. It takes an existing site from Level 1 to Level 5 in one to two sessions depending on how much plumbing already exists.

A few practical notes from running this across three sites.

Start with Discovery

It costs nothing, it's reversible, and it immediately improves how every AI crawler, not just agent-readiness scanners, perceives your domain.

Don't skip llms.txt

It is the single file that most improves agent comprehension in our experience. A well-written llms.txt is the difference between an agent knowing you run AI workshops for enterprise teams and an agent categorising you as a generic technology consultancy.

Earn the Action layer

Don't publish an MCP card until you have an endpoint behind it. Build the endpoint, test it, then publish the card. Your domain's agent reputation is worth protecting.

The skill is free to use, fork, and adapt. If you hit something it doesn't handle, open an issue.

What this changes for your business

The shift from search-engine-optimised to agent-ready is not a future concern, it's happening now. The companies that show up in AI-mediated discovery, that can be called by an agent without a human in the loop, and that expose real capabilities rather than marketing copy are the ones that will compound over the next two years.

Most sites are at Level 1. The bar for Level 5 is not high, it's just specific.

Your site should be visible to every agent that matters. Let's make it so.