Agent-Readability Lab

• 

  The agent scores a page, tests real customer questions, fixes it, and rescores, live.

Your website might be easy for a person to read. But can an AI agent actually understand it? As more people use AI to research products and services before they buy, that question decides whether your page turns up in an answer or gets skipped. Agent-Readability Lab shows you exactly where a page breaks down for an AI agent, and fixes it with you, live, on the same page you are both looking at.

Why this use case is a strong fit for WebMCP

The point of WebMCP is to let an agent act on a live page instead of guessing at it from the outside. Agent-Readability Lab turns that inward: the thing being measured is the agent's own ability to read a page, and the only honest way to measure it is to have the agent work directly on that page's live, in-browser content.

A scraper or a screenshot-driven browser agent cannot do this. They see fetched HTML or rendered pixels, not the working copy a user is editing in real time, and they cannot run a scoring pass, apply a fix, and immediately re-measure inside the same session. WebMCP is what turns the page itself into a set of tools the agent can call: analyze it, test it against real questions, rewrite it, and rescore, all against state that lives entirely in the browser. This is not "agent fetches data." It is "agent and page collaborate on the page," which is exactly the primitive WebMCP introduces.

How it creates a better user experience

Today, making a page readable for AI agents is guesswork. You publish, you hope agents parse it, and there is no feedback loop. This tool replaces that with a live, agent-verified audit:

• You paste a page and ask, in plain language, how agent-readable it is.
• You get a concrete score out of 100 with a per-signal breakdown (headings, structured data, direct answers, link clarity, scannable structure, metadata) and a ranked list of gaps.
• You watch the agent test real customer questions against the page and show you exactly which ones it cannot answer.
• You tell it to fix the problems, and the page rewrites itself in front of you as the score climbs.

The user never leaves the conversation, never opens a config screen, and never writes the structural markup themselves. They steer in natural language while the agent does the mechanical work on a shared, visible surface. It closes a feedback loop that, until now, simply did not exist.

What people and agents can do together that was hard or impossible before

Before this, you could not sit an AI agent in front of your page and have it tell you, specifically and honestly, "here are six questions a customer would ask, and here are the four I cannot answer from this page," then fix the page with you in the same breath.

That collaboration needs three things at once: the agent reasoning like a real reader, a deterministic measurement of the page's structure, and the ability to edit that page live and re-measure. WebMCP is what lets all three happen in one place. The human brings judgment ("focus on pricing and shipping"), the agent brings language and reasoning (writing the FAQ answers, catching the vague link), and the page's own tools bring the objective score. The result is a page rewritten for machine-readability, with the agent proving, in the same session, that it can now answer what it could not before.

The agent also stays grounded: in testing, it fixed the structure but flagged that exact pricing and warranty details still needed real product information it did not have. That kind of self-aware collaboration only works when the agent is operating on the real page, not a copy.

How WebMCP was implemented

The app is a single self-contained page that registers its tools through document.modelContext.registerTool. The page's editable content area is the single source of truth (the "working copy"), and every tool reads from and writes to it, so the human always sees exactly what the agent is doing.

Five tools are exposed to the agent:

• analyze_readability runs a deterministic, structural scoring pass out of 100 across six weighted signals and returns the score, a breakdown, and a ranked gap list.
• check_answerable takes questions the agent proposes and reports, per question, whether the answer is present and well-placed (answerable), present but buried, or missing.
• apply_fix applies one structural improvement at a time: add a direct-answer summary, add a descriptive heading, append FAQPage JSON-LD, rewrite vague link text, or add page metadata. The agent writes the wording; the tool handles the structure, which keeps the scoring deterministic.
• rescore re-runs the scoring pass and reports the delta so the improvement is visible.
• export_optimized returns the improved page along with the before and after scores.

The division of labor is deliberate: the agent supplies reasoning and language, the page supplies an objective, repeatable score. That keeps the numbers defensible while letting the agent do what it is genuinely good at.

What's next

Next steps are live URL ingestion through a lightweight proxy, so any published page can be audited in place; a rendered before-and-after preview; and one-click export of the generated JSON-LD. The scoring signals map directly onto how real AI answer engines select and cite sources, which is where this becomes a daily tool for anyone doing SEO, AEO, or GEO work.

Built With

• html
• javascript
• json-ld
• netlify
• openai
• webmcp