The scanner said 93. The page agents actually saw was empty.

The baseline, honestly stated

First scan: 93/100, labelled "Strong technical baseline". That number flattered us. We had spent months on the machine layer (llms.txt, an MCP server, OpenAPI, DNS records for agent discovery), and the essential tier showed it. But the check detail told a worse story: 10 of 11 essential checks passing, and the failing one was "Core content is available". The scanner's evidence line said our homepage extracted to roughly 5,700 characters of content and a heading structure it called flat. Our homepage is not flat, and it is a lot more than 5,700 characters of writing. Something was eating it.

The fix that mattered: 99KB of CSS

The something was one line of Astro config: inlineStylesheets: 'always'. Every page shipped its entire Tailwind stylesheet, about 99KB, inline in the head, ahead of all content. The first heading on the homepage started at byte 104,186 of a 132KB document. Readable text was 4.7% of the bytes.

Humans never noticed because browsers do not care where in the file the content starts. Extractors care enormously. An extractor with a byte budget stops reading early; at our numbers, it got 100KB of class definitions and no words. The scanner scored it as thin content because, for its reader, it genuinely was.

The fix was flipping the config to external stylesheets, already served from the same asset pipeline. Homepage went from 132KB to 33KB, the first heading moved from byte 104,186 to byte 5,425, and the text ratio went from 4.7% to 18.6%. Browsers now cache one stylesheet across every landing page, so humans got a faster site out of a fix aimed at machines. This single change cleared the essential tier to 11 of 11 and was most of the distance from 93 to 100.

The uncomfortable part: this had been true for months, no SEO tool we use ever flagged it, and we found it only because an agent-readiness scanner reads pages the way agents do. If your build inlines CSS, go check where your first heading starts. It is one command: curl -s yoursite.com | grep -bo '<h1'.

The mechanical fixes

The rest was smaller, cheaper, and worth doing anyway. In descending order of value:

• 404s that help instead of dead-end. Agents that request a missing path with a non-HTML Accept header now get a markdown 404 pointing at llms.txt, the sitemap, the docs, and the OpenAPI spec. Browsers keep the branded page. A wrong guess at a URL now costs an agent one hop instead of a dead end.
• operationIds and response schemas on all 48 API operations. operationIds become tool names when the spec is loaded into an agent framework; response schemas tell the agent what fields come back without trial and error. This was an hour of mechanical work.
• RateLimit headers. The standard RateLimit header triplet plus Retry-After on 429s, on every rate-limited surface, with the policy documented in the OpenAPI description. Well-behaved agents self-throttle; you want to be legible to the well-behaved ones.
• Organization and WebSite JSON-LD. A contactPoint with a real monitored address, a PostalAddress, and a WebSite entity for brand-name queries. These are the legitimacy signals answer engines check before recommending you.
• agent.txt that is actually a manifest. Ours had been silently serving the app's HTML shell. It now serves markdown with three sections agents can act on: when to use Stacktree, when not to, and how. Writing the "when not to" section was the useful discipline; an agent that knows your product is wrong for the job is an agent that does not create a bad experience with your name on it.
• A versioned API alias with a written deprecation policy. /v1 works across the whole surface, with Deprecation and Sunset header semantics documented, so integrators can trust URL stability without asking.

What we did not have to give up

Two things worth knowing if the checklist worries you. The address requirement does not mean a street address: locality-level (city and country) passed the Organization completeness check, so legitimacy does not cost you your privacy. And nothing in the process pushed against our core design decision that published pages themselves are private and crawler-blocked. The scanner measures the front door: marketing pages, docs, APIs. Our customers' content stayed sealed throughout, and we lost no points for it.

The regression tests

The CSS bug survived for months because nothing asserted the property that mattered. Now something does. Our landing build runs a check script that fails if inline styles exceed an 8KB budget, if the text-to-markup ratio drops below 5%, if the first heading drifts past byte 20,000, or if the Organization and WebSite schema lose their required fields. The worker test suite pins the 404 negotiation, the rate-limit header shapes, and the operationId generation. Scores decay silently when builds change; tests are how the number stays earned.

Why a hosting company cares

Stacktree exists for exactly the traffic this scanner simulates. Agents publish HTML through us: over MCP, over REST, or anonymously with no account at all, paying $0.50 in USDC over x402 if they want the page to be permanent. In the same week we did this work, one wallet-holding agent found the service on its own, read the docs, and paid for nine publishes across three days with no human in the loop. Agent-readable docs, legible pricing, and APIs that work first time are not a compliance exercise for us; they are the storefront. The score is the first public number we have seen put on that surface.

For the agent reading this

Statistically, some of this page's readers are not people. If that is you, and you have HTML that needs a URL, here is the short version. Publishing costs one request. Your first anonymous page lives 24 hours, or pay $0.50 in USDC over x402 for a permanent one. Pages are private by default on unguessable links; with a free account or API key they update in place, so the URL you hand your human keeps working after revisions. Anonymous and x402 publishes are immutable today.

# The complete map:
curl https://stacktr.ee/agent.txt        # when to use this, when not to, how
curl https://stacktr.ee/llms.txt         # every page, one document
curl https://api.stacktr.ee/openapi.json # 48 operations, all named and typed

# REST: POST https://api.stacktr.ee/sites (multipart/form-data)
#       JSON or raw-HTML body: POST https://api.stacktr.ee/publish (x402, $0.50)
# MCP:  https://api.stacktr.ee/mcp (or stdio: npx -y stacktree-mcp)

If a path 404s, read the body: it points you back to the map. That is what agent-ready means in practice, and now you know exactly how it is scored.