agentable-mcp
This server provides tools for auditing and analyzing websites' readiness for AI agents, including single URL audits, bulk audits, side-by-side comparisons, and leaderboard access.
Audit a single URL (
audit_url): Checks a website's readiness, returning a level (0–5, from Hostile to Autonomous), a score percentage, and detailed check results. Free for 5 uses/day; unlimited on Pro.Bulk audit (
bulk_audit): Audits up to 50 URLs simultaneously, returning a summary table with level and score for each. Requires Pro authentication.Compare URLs (
compare_urls): Side-by-side comparison of 2-4 websites (up to 8 with Pro) for agent readiness, showing scores and detailed checks.Leaderboard (
get_leaderboard): Retrieves the public leaderboard of top agent-ready sites, with an optional limit (default 20, max 50). Free, no authentication required.
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., "@agentable-mcpWhat's the agent readiness score for example.com?"
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.
agentable-core
Python SDK and MCP server for seo4agent.com — agent-readiness auditing.
Install
pip install agentable-coreRelated MCP server: coven-mcp
MCP Server (Claude Desktop / Cursor / Windsurf)
Add to your claude_desktop_config.json:
{
"mcpServers": {
"agentable": {
"command": "agentable-mcp",
"env": {
"AGENTABLE_TOKEN": "your_jwt_token"
}
}
}
}Get your token at seo4agent.com → Settings.
Available MCP tools
Tool | Description | Plan |
| Audit a single URL for agent readiness | Free (5/day) · Pro (unlimited) |
| Audit up to 50 URLs in parallel | Pro only |
| Compare URLs side by side (2 Free / up to 8 Pro) | Free + Pro |
| Public leaderboard of top agent-ready sites | Free |
Python SDK
import asyncio
from agentable import AgentableClient
async def main():
client = AgentableClient(token="your_token")
# Single audit
result = await client.audit("https://example.com")
print(f"Level {result['level']} — {result['score_pct']}%")
# Bulk audit
results = await client.bulk_audit([
"https://site1.com",
"https://site2.com",
])
# Compare
comparison = await client.compare([
"https://openai.com",
"https://anthropic.com",
])
asyncio.run(main())x402 — Pay per audit (no account required)
The REST endpoint supports the x402 payment protocol — pay $0.10 USDC per audit directly from any EVM wallet on Base, no account needed.
import { wrapFetchWithPayment } from "@x402/fetch";
import { CdpX402Client } from "@coinbase/cdp-sdk/x402";
const client = new CdpX402Client();
const fetchWithPayment = wrapFetchWithPayment(fetch, client);
const res = await fetchWithPayment("https://seo4agent.com/audit/run", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ url: "https://example.com" }),
});See the x402 buyer quickstart for full setup.
Environment variables
Variable | Default | Description |
| — | JWT token from seo4agent.com |
|
| API base URL |
Available Tools
4 toolsaudit_urlA
Audit a website for AI/agent readiness. Returns a readiness level (0-5), score percentage, and individual check results. Level 5 = Autonomous (fully agent-ready), Level 0 = Hostile. Free plan: 5 audits/day. Pro: unlimited.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The website URL to audit (e.g. https://example.com) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and discloses key behaviors: it returns a readiness level, score percentage, and individual check results, and defines the 0-5 scale. It also notes plan limits (5 audits/day free, unlimited Pro), adding useful operational context.
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 concise and front-loaded, with no wasted words. It states the purpose, then the return value, the scale meaning, and plan limits in four short sentences, each earning its place.
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?
The tool has a single parameter and no output schema, but the description covers the essential return value semantics (level meanings) and rate limits. It is complete enough for an agent to select and invoke the tool correctly, though it could mention error handling or prerequisites.
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?
The input schema already fully describes the only parameter (url) with 100% coverage. The description adds no additional parameter-specific meaning beyond what the schema provides, so the baseline score of 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?
The description clearly states the tool's function with a specific verb and resource: 'Audit a website for AI/agent readiness.' It also distinguishes itself from siblings by focusing on a single website and describing its specific output, unlike bulk_audit or compare_urls.
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 does not provide explicit guidance on when to use this tool versus alternatives like bulk_audit or compare_urls. It mentions plan limits but gives no contextual cues for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
bulk_auditA
Audit multiple websites at once (up to 50). Returns a summary table with level and score for each URL. Requires Pro subscription.
| Name | Required | Description | Default |
|---|---|---|---|
| urls | Yes | List of URLs to audit (max 50, Pro only) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the batch size cap, the output structure (summary table with level and score), and the Pro subscription prerequisite. It does not explicitly state side effects (though audit implies read-only) or failure behavior, but the key behavioral traits are covered for a simple tool.
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 three concise sentences, each conveying essential information: action and limit, return output, and subscription requirement. It is front-loaded with the primary purpose and contains zero filler or repetition.
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 tool with one simple parameter, no output schema, and no annotations, the description covers the purpose, input limit, output format, and key prerequisite. It lacks details on error handling or invalid URL behavior, but overall it is sufficiently complete for its 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?
Schema description coverage is 100%: the only parameter 'urls' is already described in the schema with 'List of URLs to audit (max 50, Pro only)'. The description merely reiterates the limit and Pro requirement without adding new parameter-specific meaning, so the baseline of 3 applies.
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 action ('Audit') and resource ('multiple websites'), with an explicit batch limit that distinguishes it from the sibling tool audit_url. It also specifies the return format ('summary table with level and score'), making the purpose unambiguous.
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 clearly indicates when to use this tool: when auditing up to 50 websites at once. It does not explicitly name alternatives (e.g., audit_url for single URLs) or state exclusions, but the context is clear. The Pro subscription requirement also helps set expectations for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compare_urlsA
Compare websites side by side for agent readiness. Free plan: up to 2 URLs. Pro plan: up to 8 URLs. Returns scores and check results for each URL.
| Name | Required | Description | Default |
|---|---|---|---|
| urls | Yes | 2–8 URLs to compare (2 for Free, up to 8 for Pro) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry full behavioral disclosure. It does state plan limitations (Free up to 2 URLs, Pro up to 8) and that it 'Returns scores and check results for each URL,' which gives some insight into output. However, it does not describe auth requirements, error handling, or how 'agent readiness' is computed, leaving significant behavioral gaps.
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 concise, with three sentences that each serve a clear purpose: stating the core action, specifying plan limits, and indicating the return type. It is front-loaded with the most critical information and contains no filler or redundancy.
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 that there is no output schema, the description should clarify what 'scores and check results' include in more detail. It also does not explain the meaning of 'agent readiness' or define how the comparison is performed. While the single parameter and simple purpose reduce complexity, the description leaves gaps in understanding the output and tool nuances, making it adequate but not comprehensive.
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?
The input schema already fully describes the single parameter 'urls' with min/max items and plan-based limits (100% schema description coverage). The description repeats these limits without adding any new semantic meaning or examples. Therefore, it adds no extra value beyond the schema, warranting the baseline score of 3.
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's function: 'Compare websites side by side for agent readiness.' The verb 'compare' and the resource 'websites' are specific, and the phrase 'side by side' distinguishes it from single-URL audit tools like audit_url. It also implies a comparison use case that differs from bulk_audit and get_leaderboard.
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 implicitly provides usage context by focusing on comparison of multiple URLs, which suggests it is appropriate when you need to evaluate several websites together. However, it does not explicitly mention when not to use it or name alternatives like 'use audit_url for a single URL.' Thus, it has clear context but lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_leaderboardA
Get the public leaderboard of top agent-ready websites. No authentication required.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of results to return (default 20, max 50) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. It adds that no authentication is required and that the data is public, covering access control. However, it does not disclose return format, ordering, or any potential side effects, though 'get' implies read-only. The description provides some transparency but lacks deeper behavioral context.
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 extremely concise, consisting of two short sentences that immediately convey the tool's purpose and a key usage note. Every word earns its place, and there is no repetition of schema details.
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?
The tool is simple with one optional parameter and no output schema. The description explains what the tool does and that no authentication is needed. While it does not detail the exact return values, 'leaderboard' strongly implies a ranked list of websites, and the schema covers the limit. Overall, it is adequately complete for the tool's 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?
The schema fully describes the 'limit' parameter with default and max values, so the description does not need to add much. The description does not mention the parameter at all, but the schema coverage is 100%, and the meaning of 'limit' is self-explanatory. Thus, a baseline score of 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?
The description uses the specific verb 'Get' and identifies the resource as 'public leaderboard of top agent-ready websites'. This clearly distinguishes it from sibling tools like audit_url and bulk_audit, which focus on auditing rather than retrieving a leaderboard.
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 provides a clear context for when to use the tool: when the public leaderboard of agent-ready websites is needed. It also explicitly notes that no authentication is required, which is useful usage information. However, it does not mention exclusions or alternatives, though the tool's purpose is distinct from its siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a clearly distinct purpose: single URL audit, bulk audit, side-by-side comparison, and leaderboard retrieval. There is no overlap or ambiguity in their functions.
Most tools follow a verb_noun pattern (audit_url, compare_urls, get_leaderboard), but bulk_audit is an adjective_noun deviation. Still, all names are snake_case and readable, making the inconsistency minor.
Four tools is well-scoped for a focused auditing service. Each tool covers a distinct workflow without redundancy or unnecessary bloat.
The tool set covers the core needs of an auditing service: single audit, bulk audit, comparison, and leaderboard access. Since this is a read-only domain, there are no missing CRUD operations or dead ends.
Maintenance
Related MCP Connectors
Scan any website or MCP server for agent readiness: 0-100 score, a fix per failing check. Free.
MCP server for building and testing AI agents with multi-model experimentation and insights.
Screenshot, diff, audit and sitemap-capture any web page — 5 MCP tools for AI agents.
Website QA for your coding agent: audit SEO, performance, security, accessibility over MCP.
Related MCP Servers
- AlicenseBqualityBmaintenanceMCP server that enables AI agents to perform comprehensive web audits using Google Lighthouse with 13+ tools for performance, accessibility, SEO, and security analysis.111,18667MIT

coven-mcpofficial
FlicenseNot gradedqualityDmaintenanceMCP server for website auditing and AI visibility measurement using the COVEN v2.0.1 methodology, offering tools to scan, score, and optimize sites for agent traffic.- AlicenseAqualityBmaintenanceAn MCP server that gives AI agents tools to inspect a website's visibility to AI answer engines, including crawler permissions, llms.txt, structured data, on-page signals, and a full 29-check AI-readiness audit.554MIT
- FlicenseAqualityDmaintenanceAn MCP server that audits websites for accessibility (WCAG 2.1 AA/EAA), performance, SEO, design quality, and mobile responsiveness, providing actionable scores, grades, and prioritized fixes.6
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/varustamov/agentable-core'
If you have feedback or need assistance with the MCP directory API, please join our Discord server