Agent Readiness MCP
The Agent Readiness MCP server scans websites and measures their ASO (Agent Signal Optimization) Score — a metric indicating how discoverable, trustable, and usable a site is by AI agents.
scan_site: Runs a comprehensive 34-check audit across discoverability, content accessibility, bot access, interoperability, commerce, and identity/trust. Returns an ASO Score (0–100), maturity level (ASO-0 to ASO-5), per-pillar scores, per-check evidence, and prioritized recommendations.check_signal: Runs a single named check (e.g.llms-txt,a2a-agent-card,mcp-server-card) against a site for targeted validation or debugging without a full scan.list_checks: Browses the full catalog of supported checks, including IDs, names, categories, descriptions, and spec links.get_fix_plan: Scans a site and returns a prioritized remediation roadmap with point values per fix and ready-to-paste templates (e.g.robots.txt,llms.txt,agent.json, A2A agent card,pricing.json,security.txt).get_aso_framework: Retrieves the full ASO framework reference — six signal pillars with weights, maturity level definitions, certification thresholds, and the scoring rubric — without scanning any site.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Agent Readiness MCPScan https://example.com for agent readiness"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
agent-readiness-mcp — the free Agent Readiness Scanner
What's your ASO score?
SEO made you visible to search engines. ASO (Agent Signal Optimization) makes you discoverable, trustable, and payable by the AI agents that are becoming the web's next visitors.
agent-readiness-mcp is the free, open-source Agent Readiness MCP — an MCP server that scans any website and produces an Agent Readiness Report scored on the open ASO framework. The beta npm package is @forgemeshlabs/agent-readiness-mcp.
This release tracks Google's current agent-readiness guidance without overstating it: Google Search says traditional SEO fundamentals still apply to generative AI search, llms.txt is ignored by Google Search itself, and browser agents benefit from clean DOM, screenshot, and accessibility-tree signals. The scanner keeps llms.txt because non-Google agents use it, and adds a browser-agent UX check for semantic controls, linked labels, ARIA/role fallbacks, and hidden-overlay risk.
Beta. Experimental ASO scanner for evaluating whether agents can discover, trust, understand, and use a website/API/tool. ASO scoring is experimental and will evolve as agent standards mature.
=== Agent Readiness Report: https://example.com ===
ASO Score: 70/100
Agent Readiness: Ready
Level: ASO-4 Trustable — Agents can verify trust, reputation, and operational signals.
Discoverability 20/20 Identity 15/20 Trust 11/15
Commerce 5/15 Reputation 4/15 Memory 15/15What it checks — 34 signals across 6 pillars
Find gaps in discovery, trust, interoperability, and commerce — every emerging agent standard in one scan:
Pillar / Category | Checks |
Discovery | robots.txt, sitemap.xml, Link headers, DNS-AID ( |
Content | Markdown content negotiation, llms.txt, LLM-readable docs ( |
Bot Access | Explicit AI crawler rules (GPTBot, ClaudeBot, Google-Extended, PerplexityBot…), Content Signals, Web Bot Auth |
Interoperability | API Catalog (RFC 9727), OAuth discovery (RFC 8414), OAuth Protected Resource (RFC 9728), auth.md, MCP Server Card ( |
Commerce | x402, MPP, UCP, ACP, machine-readable pricing |
Identity & Trust | HTTPS enforcement, JSON-LD/schema.org, agent-friendly browser UX, OpenAPI, agent.json, security.txt, status endpoint, versioning, cross-file identity & signal consistency |
Every check returns pass / partial / fail with concrete evidence and a fix recommendation. Results roll up into the six ASO pillars (Discoverability 20, Identity 20, Trust 15, Commerce 15, Reputation 15, Memory 15) → your ASO Score and maturity level.
Related MCP server: ASO Score MCP
Install
Requires Node.js ≥ 18. Published on npm as @forgemeshlabs/agent-readiness-mcp — no clone or build needed.
npm install -g @forgemeshlabs/agent-readiness-mcpOr skip the install entirely and run it with npx (recommended for MCP clients):
npx -y @forgemeshlabs/agent-readiness-mcpClaude Code
claude mcp add aso -- npx -y @forgemeshlabs/agent-readiness-mcpClaude Desktop / Cursor / Windsurf (any MCP client)
{
"mcpServers": {
"aso": {
"command": "npx",
"args": ["-y", "@forgemeshlabs/agent-readiness-mcp"]
}
}
}Development (from source)
Only needed if you're hacking on the scanner itself:
git clone https://github.com/forgemeshlabs/agent-readiness-mcp
cd agent-readiness-mcp
npm install && npm run build
claude mcp add aso -- node /path/to/agent-readiness-mcp/dist/index.jsTools
Tool | What it does |
| Full ASO scan → Agent Readiness Report: ASO Score, level, pillar breakdown, all 34 checks with evidence + recommendations |
| Prioritized remediation plan with ready-to-paste templates (robots.txt AI rules, llms.txt, agent.json, A2A agent card, MCP server card, x402 manifest, pricing.json, security.txt, status endpoint) |
| Run one specific check (e.g. |
| Catalog of every check with spec links |
| The ASO rubric: pillars, weights, levels, certification thresholds |
Use scan_site for a full baseline, check_signal for a single named signal, get_fix_plan for copy-paste remediation, list_checks to discover valid signal IDs, and get_aso_framework to explain the scoring model without scanning a site.
Try it: "Scan example.com for agent readiness" · "What's my ASO score?" · "Give me a fix plan to make my site agent-ready."
CLI smoke test (from a source checkout)
npm run smoke -- https://your-site.comGlama / registry metadata
This repository includes glama.json for Glama MCP registry ownership and install metadata.
Package:
@forgemeshlabs/agent-readiness-mcpCurrent release:
v0.1.2Transport: local
stdioAuthentication: none required for local
stdiouse. The scanner does not ask for API keys, tokens, cookies, or third-party credentials.HTTP deployment: not enabled by this npm package. Any public HTTP deployment of this scanner must add authentication, per-client rate limits, request logging, and an egress policy before exposure.
Recommended Glama/MCP install command:
npx -y @forgemeshlabs/agent-readiness-mcpExample usage after connecting the server to an MCP client:
Scan https://example.com for agent readiness.
Give me the ASO fix plan for example.com.
Check only the llms-txt signal for example.com.
List the ASO scanner checks.Release verification:
Git tag:
v0.1.2npm package:
@forgemeshlabs/agent-readiness-mcpMCP server version:
0.1.2
v0.1.2 is the Agent Readiness TDQS refresh: it improves Glama tool-selection guidance, adds Glama badges, and keeps registry metadata ready for a refreshed Glama release.
Glama release build
Glama installability requires a Glama release, which is a containerized build created from the Glama Dockerfile admin page, not a GitHub release. This repo includes a production Dockerfile and GLAMA.md with the build spec values to use in Glama:
Build steps:
npm ci
npm run build
npm prune --omit=devRuntime command:
node dist/index.jsIn Glama's CMD arguments field, enter:
["node", "dist/index.js"]Do not leave CMD arguments as []; Glama validates that field separately from the Dockerfile CMD.
The ASO framework
SEO ranks pages for people. ASO prepares services for agent selection, invocation, payment, and repeat use.
Level | Name | Score |
ASO-0 | Invisible | 0–9 |
ASO-1 | Discoverable | 10–29 |
ASO-2 | Understandable | 30–49 |
ASO-3 | Invocable | 50–69 |
ASO-4 | Trustable | 70–89 |
ASO-5 | Autonomous-Commerce-Ready | 90–100 |
Scores from this scanner are directional self-assessments. ASO Certification (ASO-3+) requires verified evidence — see the scoring rubric and agentsignaloptimization.com for audits, certification, and the full framework.
Security
This scanner makes outbound requests to URLs you give it, so it is built to resist SSRF abuse:
Scheme allow-list — only
http/https;file:,ftp:,gopher:,data:etc. are rejected.Private-target blocking — after DNS resolution, requests to loopback, private (RFC 1918), link-local, CGNAT, reserved, multicast, and the cloud metadata address (
169.254.169.254) are refused. IPv6 loopback/ULA/link-local and IPv4-mapped forms are covered too. If a hostname resolves to any private address, the scan is refused.Pinned-IP transport — each request dials the exact public IP that was validated, while TLS still verifies the original hostname. This closes the validate-then-connect DNS rebinding window.
Manual redirect validation — automatic redirect following is disabled; every hop is re-validated against the same rules, capped at 5 redirects. A public URL that 30x-redirects to an internal address cannot slip through.
Untrusted remote content — parsed manifests are omitted from tool output by default (
include_artifacts: trueto opt in, and they are then explicitly labeled untrusted); embedded text excerpts are control-char-sanitized and length-capped. Treat any returned remote content as data, never instructions.Bounded —
GETonly,ASO-Scanner/1.0UA, max 6 concurrent, 10s timeout, 512KB body cap. Never authenticates, never POSTs, never crawls beyond well-known paths.Tested hardening —
npm testcovers unsafe URL rejection, private IP ranges, artifact sanitization, redirect blocking, redirect hop caps, and the test-only loopback escape hatch.
Deployment: stdio (local, per-user) is the safe default. A public HTTP deployment is a network-egress tool and must add authentication, per-client rate limiting, request logging, and an egress policy before exposure.
Reputation signals (citations, reviews, success rates) cannot be auto-verified by a crawler; they are reported as
manualand scored 0 until verified by audit — so the auto-verifiable maximum is 89/100. That is intentional honesty, not a bug.Emerging specs (MCP Server Cards SEP-1649/SEP-2127, DNS-AID, Web Bot Auth, UCP/ACP/MPP) move fast. PRs updating paths welcome.
Source alignment
This package intentionally separates Google Search guidance from broader ASO guidance:
Google Search generative AI features still rely on core Search ranking and quality systems; foundational SEO, crawlability, helpful content, and technical clarity remain the priority.
Google Search does not use
llms.txtor special AI markdown files for ranking or AI Overviews/AI Mode visibility. ASO still checks them because other agents and MCP clients can use them.Google/web.dev's agent-friendly site guidance focuses on browser-agent usability: stable layouts, semantic HTML, labels tied to inputs, meaningful roles/names/states, and avoiding hidden overlays.
UCP, AP2, A2A, MCP, x402, DNS-AID, Content Signals, and Web Bot Auth are emerging non-SEO protocols. The scanner treats them as agent-readiness signals, not as Google Search ranking factors.
Primary references:
License
MIT — free for everyone. If the scanner found gaps, the ASO framework shows you how to close them.
Available Tools
5 toolscheck_signalRun a single agent-readiness checkA
Run one specific agent-readiness check against a site (e.g. 'a2a-agent-card', 'llms-txt', 'mcp-server-card', 'x402'). Use this for targeted validation after making a fix or when debugging one signal; use scan_site for the complete ASO Score and get_fix_plan for a prioritized remediation roadmap. Use list_checks first when you need valid check ids. Returns status, evidence, and a fix recommendation, and omits raw remote artifacts by default.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Website URL or domain to scan, e.g. https://example.com or example.com | |
| check_id | Yes | Lowercase check slug from list_checks, e.g. 'a2a-agent-card', 'llms-txt', 'mcp-server-card', or 'x402'. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist; the description carries full burden. It discloses return values ('status, evidence, and a fix recommendation') and a default behavior ('omits raw remote artifacts by default'), but does not explicitly state that the tool is read-only, whether it requires authentication, or any rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences with no wasted words. Front-loads purpose, then provides usage guidance, then lists output and behavior. Every sentence serves a distinct function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter tool with no output schema, the description covers purpose, usage, and return structure adequately. It also references list_checks for valid IDs. Missing minor details like whether the operation is synchronous, but sufficient for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds no additional meaning beyond the schema's descriptions for url and check_id; it only provides examples, which are already implied by the pattern.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly names the action ('Run one specific agent-readiness check'), identifies the resource ('a site'), provides concrete examples of check IDs, and distinguishes from siblings like scan_site and get_fix_plan.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance on when to use this tool ('targeted validation after making a fix or when debugging one signal'), when not to use it ('use scan_site for the complete ASO Score and get_fix_plan for a prioritized remediation roadmap'), and a prerequisite action ('Use list_checks first').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_aso_frameworkASO framework referenceA
Return the ASO (Agent Signal Optimization) framework reference: the six signal pillars with point weights, the Agent Readiness Index maturity levels (ASO-0 through ASO-5), certification thresholds, and the scoring rubric. Use this for education, documentation, or explaining how scores are calculated; it does not fetch or scan a website. Source: https://agentsignaloptimization.com
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool is read-only, does not fetch or scan, and provides a source URL. This clear behavioral disclosure is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. The key information is front-loaded, and every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description fully explains the return contents, includes a source URL, and covers all necessary context for a reference tool with no parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so baseline is 4. The description adds meaning by explaining what the tool returns, which goes beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the ASO framework reference with specific components (six signal pillars, maturity levels, etc.). It distinguishes itself from siblings by explicitly stating it does not fetch or scan a website.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description tells when to use the tool (education, documentation, explaining scores) and what it does not do. While it does not explicitly name alternatives, the context of sibling tools like scan_site and check_signal provides implicit differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_fix_planGet a prioritized ASO fix planA
Scan a site and return a prioritized remediation plan: which signals to add first, the ASO Score points each fix is worth, and ready-to-paste artifact templates (robots.txt AI rules, llms.txt, agent.json, A2A agent-card.json, MCP server card, x402 manifest, pricing.json, security.txt, status endpoint). Use this when the user wants an implementation roadmap or copy-paste fixes; use scan_site when they need full evidence and per-check scoring, and use check_signal to verify one completed fix.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Website URL or domain to plan fixes for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. 'Scan a site' implies read-only but doesn't explicitly state safety, side effects, or authorization needs. Lacks explicit disclosure that it does not modify the site.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Relatively concise single sentence front-loading purpose, followed by usage guidance. Slight run-on but no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool (1 param, no output schema), description covers output contents (plan, points, templates) and provides alternatives. Lacks only explicit safety behavior, but otherwise complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter (url) with schema coverage 100%. Description does not add extra semantic beyond schema's 'Website URL or domain to plan fixes for'. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states verb and resource: 'Scan a site and return a prioritized remediation plan'. Distinguishes from siblings by naming alternatives (scan_site, check_signal) and their use cases.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells when to use this tool vs alternatives: 'Use this when the user wants an implementation roadmap or copy-paste fixes; use scan_site when they need full evidence...'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_checksList all agent-readiness checksA
List the full catalog of supported ASO checks with id, name, category, description, and spec link. Use this before check_signal to discover valid check ids, to build UI filters, or to explain the scanner coverage; it does not scan a site or produce a score.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that the tool is a read-only catalog listing with no side effects. No annotations exist, so description fully carries the burden and does so transparently.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with action and output fields. Every sentence adds value—no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Complete for a parameterless listing tool: describes output, use cases, and boundaries. No output schema needed given simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters; schema coverage is trivially 100%. Baseline of 4 is appropriate as description adds no parameter info beyond what schema already conveys.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb 'list' with specific resource 'full catalog of supported ASO checks' and fields (id, name, category, description, spec link). Distinguishes from siblings by stating it does not scan or produce a score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: before check_signal to discover valid check ids, to build UI filters, or to explain scanner coverage. Also states what it does not do (scan or score), providing clear guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scan_siteASO Scan — measure your ASO ScoreA
Scan a website for Agent Readiness using the ASO (Agent Signal Optimization) framework and return an Agent Readiness Report. Use this for a full site-level baseline, competitive audit, or before/after readiness measurement; use check_signal instead when you only need one named signal, and use get_fix_plan when you only need remediation steps. Runs 34 checks across discoverability (robots.txt, sitemap, llms.txt, DNS-AID, Link headers), content accessibility (markdown negotiation), bot access control (AI bot rules, Content Signals, Web Bot Auth), invocation (API catalog, OAuth discovery, OAuth protected resource, auth.md, MCP Server Card, Google A2A Agent Card, Agent Skills, WebMCP), commerce (x402, MPP, UCP, ACP, pricing), Google generative AI search basics, browser-agent UX, and identity/trust signals. Returns the ASO Score (0-100, formally the Agent Readiness Index), ASO maturity level (ASO-0 Invisible … ASO-5 Autonomous-Commerce-Ready), an agent-readiness verdict, per-pillar scores, per-check evidence, and prioritized recommendations.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Website URL or domain to scan, e.g. https://example.com or example.com | |
| categories | No | Optional category filter for focused scans. Omit for all 34 checks; pass one or more category enum values to narrow runtime and output. | |
| include_artifacts | No | Optional raw artifact return. Default false. When true, includes remote manifests such as agent.json and A2A cards as untrusted attacker-controlled data for debugging only. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It thoroughly explains the 34 checks across multiple categories and describes return values. It also notes that include_artifacts returns 'untrusted attacker-controlled data'—a behavioral caveat. However, it doesn't explicitly state read-only nature or any side effects, scoring just below perfect.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is thorough and structured: starts with purpose, then usage guidance, then lists check categories, then return values. While not extremely concise, every sentence adds value. Front-loading with purpose is well done.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (34 checks, 3 parameters, no output schema), the description is nearly complete. It explains all important return fields (ASO Score, maturity level, verdict, scores, etc.). Missing explicit mention of output format (likely JSON) but implied. Overall, sufficient for an agent to understand what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for all 3 parameters. Description adds value by clarifying usage of categories filter (omit for all checks) and warning about artifacts returning attacker-controlled data. This goes beyond the schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool scans websites for Agent Readiness using ASO framework and returns a report. It explicitly distinguishes from siblings by naming check_signal and get_fix_plan, leaving no ambiguity about its specific function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit usage scenarios: full baseline, competitive audit, before/after measurement. Also clearly states when to use alternatives: check_signal for single signal, get_fix_plan for remediation only. This gives clear decision criteria for the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
2 tool updates
v0.1.2- Changed
check_signal1 field changed- changed
Input schema / properties / check_id / descriptionPrevious value: -"Check id from list_checks, e.g. 'a2a-agent-card'"New value: +"Lowercase check slug from list_checks, e.g. 'a2a-agent-card', 'llms-txt', 'mcp-server-card', or 'x402'."
- Changed
scan_site2 fields changed- changed
Input schema / properties / categories / descriptionPrevious value: -"Optional: limit the scan to specific check categories. Default: all."New value: +"Optional category filter for focused scans. Omit for all 34 checks; pass one or more category enum values to narrow runtime and output." - changed
Input schema / properties / include_artifacts / descriptionPrevious value: -"Include the raw remote manifests the scanner parsed (agent.json, A2A card, etc.). These are UNTRUSTED attacker-controlled content; off by default."New value: +"Optional raw artifact return. Default false. When true, includes remote manifests such as agent.json and A2A cards as untrusted attacker-controlled data for debugging only."
5 tool updates
v1.0.0- First observed
check_signal - First observed
get_aso_framework - First observed
get_fix_plan - First observed
list_checks - First observed
scan_site
TDQS
Each tool has a clearly distinct purpose: checking a single signal, retrieving the framework reference, getting a remediation plan, listing available checks, and performing a full scan. Descriptions explicitly contrast with other tools to prevent confusion.
All tool names follow a consistent verb_noun pattern (check_signal, get_aso_framework, get_fix_plan, list_checks, scan_site) with no deviations.
5 tools is well-scoped for the domain of agent readiness scanning, covering all essential operations without unnecessary bloat.
The tool set covers the full lifecycle: listing checks, running individual checks, performing a full scan, generating a fix plan, and providing the underlying framework reference. No obvious gaps.
Maintenance
Related MCP Connectors
Scan any website for AI agent readiness, payment protocols, and discovery endpoints
Scan any website for AI readiness — 100-point score across 6 AEO categories in seconds.
Scan any website's AI readiness: AI search visibility and AI agent usability. Free, no auth.
Score any website's AI-agent readiness. Open Agent Registry scanner + platform tools.
Related MCP Servers
- AlicenseAqualityAmaintenanceScans any website and produces an Agent Readiness Report scored on the open ASO framework.53592MIT

ASO Score MCPofficial
AlicenseAqualityAmaintenanceScans websites to evaluate agent-readiness and produce an ASO Score Report across 34 signals, helping improve discoverability, trust, and interoperability for AI agents.253661MIT- AlicenseNot gradedqualityAmaintenanceEnables AI agents to scan any website for agent-readiness and generate the necessary artifacts (llms.txt, WebMCP scaffold, structured data) to make it agent-ready.18MIT
- AlicenseNot gradedqualityAmaintenanceEnables AI coding agents like Claude and Cursor to audit websites for AI agent readiness, checking 199 rules across agentic discovery, content structure, and technical SEO.17Apache 2.0
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/forgemeshlabs/agent-readiness-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server