Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well beyond the annotations by disclosing that this is an asynchronous run that takes about a minute and returns a run_id for polling, plus concrete rate limits (two a day per address) and tiered allowances. The annotations only flag non-read-only, non-idempotent, open-world; the description supplies the operational context an agent actually needs.

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?

Front-loads the scope before the operational details, and each sentence carries weight (scope, async flow, quotas). It is dense and somewhat run-on with nested parentheticals, but nothing is wasteful.

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?

With an output schema present, return values need not be described; the description instead covers the async lifecycle, the follow-up call, and quota behavior, which is exactly what remains ambiguous. Nothing an agent needs to invoke it correctly is missing.

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% and the single url parameter is already documented with examples ('example.com or https://example.com'), so the description adds little param detail. Baseline 3 applies when the schema does the heavy lifting.

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?

Names a specific verb and resource ('AI visibility audit') and enumerates exactly what it covers: identity files, crawler policy, schema graph, page health, and answer-engine naming. It is clearly distinguishable from siblings like atlas_search or check_identity.

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 routes the agent to the follow-up tool ('call get_analysis with that id') after the run completes, and specifies the conditions under which different account tiers apply. When-to-use and the alternative are both stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the behavioral burden. It discloses that the operation is a read, that it runs locally, that no account is needed, and that it classifies crawlers into live-question and training-data categories. This is meaningful context, though edge cases like missing robots.txt are not discussed.

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 focused sentences: it states the action, explains the meaningful distinction, and gives an operational note. Every sentence adds value and the main behavior is front-loaded.

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 one-parameter tool with no output schema, the description explains what the tool does and what kinds of results it produces. It could be more complete by describing output format or failure behavior, but the core agent decision and invocation need are well covered.

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 already covers the single 'url' parameter 100%, including an example. The description adds little parameter-specific meaning beyond contextualizing it as a site whose robots.txt is read, 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 states a specific verb-resource pair: 'Read a site's robots.txt' and 'say which AI crawlers may fetch it.' It clearly separates the tool from siblings by focusing on robots.txt + AI crawler classification, not identity files or page signals.

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 implies when to use the tool — when assessing AI crawler visibility — and even explains the practical consequence of blocking different crawler types. However, it does not explicitly mention alternatives or state conditions for when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, openWorld, idempotent, and non-destructive, so safety is covered. The description adds real context beyond them: it is free, instant, requires no account, and does not invoke any model. It doesn't discuss rate limits or failure modes, but the behavioral picture is solid.

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?

Front-loaded with the value proposition and the routing hint is placed at the end where it belongs. The enumerations are dense but each clause adds distinct information; it is on the longer side but not padded.

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?

An output schema exists so return values need not be described, yet the description still summarizes them, and the sibling routing closes the main ambiguity. For a single-parameter read tool, an agent has everything needed to call it 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% and the single url parameter is already documented in the schema. The description reinforces that the target is a public website but adds no syntax or format detail beyond what the schema provides. Baseline 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?

States a specific verb+resource ('read a website the way an AI engine does') and enumerates exactly what it returns: crawler access from robots.txt, identity files, Organization schema, a score out of 100, and named fixes. It clearly distinguishes itself from the sibling analyze_site by contrast.

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 frames the use case ('before it ever answers about it') and names the alternative with the selecting condition: 'for whether the engines actually name the site, run analyze_site.' The 'No model is asked' line reinforces when this tool applies versus the model-based sibling.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Despite no annotations, the description discloses key behavioral facts: it probes a site, runs locally, requires no account, and reports which files exist. This gives an agent a reasonable sense of the tool's operation and side effects, though failure modes and network behavior are not covered.

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 compact sentences with the main action front-loaded and the operational constraints in a single clause. No filler or redundant restating of the tool name.

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 one-parameter probe tool with no output schema and no annotations, this is complete: it states what it checks, what it reports, and the access model. Nothing an agent needs to invoke it correctly is missing.

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 the existing url parameter description already covers the only parameter. The tool description adds no parameter-specific detail, but none is really needed beyond what the schema provides.

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 identifies a specific action (probe a site), a specific resource class (identity files for AI engines), and explicitly names examples. Enough to distinguish from check_ai_access and check_page_signals by the object being checked.

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 supporting context ('Runs locally, no account needed') but no explicit when-to-use guidance or direction to sibling tools. An agent can infer the intended use from the tool name and description, but exclusion criteria are absent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must carry the behavioral disclosure. It does disclose that the operation runs locally, requires no account, and is read-only in nature ('Read... report'). But it does not mention potential limitations such as network requirements, redirect handling, or behavior when the homepage lacks certain signals. This is adequate but not comprehensive for a tool with zero annotation support.

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 a single well-structured sentence that front-loads the core action, then lists the exact signals, and ends with the deployment/access note. Every clause adds value, and there is no repetition of schema or tool name. This is highly efficient.

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 one-parameter read tool with no output schema, the description is largely complete: it states the operation, the target (homepage), the exact signals reported, and the access requirements. It could go slightly further by describing the output format or edge cases, but the enumeration of signals makes the expected return clear enough for an agent to invoke the tool 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 for the only parameter is 100%: the 'url' field already includes a description with examples. The tool description adds the notion of reading the 'homepage', which slightly clarifies the parameter's semantic scope. Since the schema carries the parameter meaning, the description only needs minimal contribution, so the baseline 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 uses a specific verb ('Read') and names the exact resource ('a site's homepage') with a concrete list of signals reported (title, description, canonical, hreflang, JSON-LD Schema.org types). This is clearly distinguishable from sibling tools like check_ai_access and check_identity_files, making the tool's purpose immediately clear.

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 conveys a clear usage context: analyzing on-page SEO/structured-data signals from a homepage. The note 'Runs locally, no account needed' is a practical guideline, and the sibling tool names further clarify when this tool fits. However, it does not explicitly state when this tool should be avoided or name an alternative, so it falls just short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations cover the safety profile (readOnly, idempotent, openWorld, non-destructive), and the description adds behavior beyond them: the call is free, resolves instantly, asks no model, and — importantly for budgeting — "counts two identity checks." That quota/cost disclosure is the kind of context an agent cannot get from annotations or schema.

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?

One dense sentence, front-loaded with the core framing ("Your site against a competitor's, read the way an AI engine reads them") before the output list. The enumeration is long but every item is a distinct deliverable, so little is wasted; it borders on list-heavy for a single sentence.

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?

With annotations carrying safety and an output schema present, the description does not need to explain return values — yet it still sketches them, which aids discovery. Combined with the cost/instant/counts-two-checks note, an agent has enough to call this correctly; only the sibling-routing gap keeps it from a 5.

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% and both parameters are documented with examples, so the schema already carries param meaning. The description only restates the roles ("your site against a competitor's") without adding format or constraint detail, which is the baseline-3 case when the schema does the heavy lifting.

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 gives a concrete verb+resource (compares two sites as an answer engine reads them) and enumerates the outputs: identity score, crawler access, identity files, Organization schema, and lead differences. It is clear about what the tool produces, but never distinguishes itself from overlapping siblings like atlas_compare, analyze_site, or check_identity, so an agent could still hesitate between them.

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?

Usage is only implied by "Your site against a competitor's" — the agent can infer this is for benchmarking one site against a rival, but there is no explicit when-to-use, when-not, or named alternative (e.g. use check_identity for a single site). The note that it is "free and instant" hints at a low-cost choice but does not frame it as a routing criterion.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral context beyond the annotations: an authorization constraint (only the account that started the run, or for a guest the same address, can read it) and the fact that the payload evolves between in-progress and finished states. It does not cover rate limits or how long a run is retained.

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 tight sentences with zero filler, and the most decision-relevant facts are front-loaded: what the tool reads, what it returns over time, then the ownership restriction. Every clause earns 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?

An output schema exists, so the description need not spell out return values, and it still sketches the shape (progress, score out of 100, top fixes). The authorization restriction is the one non-obvious requirement for correct invocation, and it is stated explicitly. Nothing an agent needs to call this correctly is missing.

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 is a single parameter with 100% schema description coverage ('The id analyze_site returned'), so the schema already carries the semantics. The description reinforces run_id's provenance by tying it to a run 'started by analyze_site' but adds no format, syntax, or validation detail beyond that. Baseline 3 is appropriate when the schema does the heavy lifting.

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?

States a specific verb and resource ('Read an audit') and immediately distinguishes itself from its producer sibling by naming analyze_site as the tool that starts the run. The description also defines what the read returns at each stage (progress, then score out of 100 and top fixes), so an agent can tell it apart from analyze_site without opening either schema.

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?

Makes the lifecycle explicit: analyze_site starts a run, get_analysis reads it, and the result changes over time (progress while running, then final score). That gives clear context for when to call it. It stops short of stating exclusions or alternatives beyond the implied pairing with analyze_site, so it lands at 4 rather than 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint/idempotentHint/non-destructive, so the safety profile is covered. The description goes further by declaring the exact return payload — URL, Claude Code command, Cursor/VS Code install links, and the claude.ai/ChatGPT custom-connector step — which is real behavioral information beyond the annotations.

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 first sentence front-loads a dense parenthetical catalog of servers and features that is hard to parse ('signed in: add a tool, its card, premium'). The trigger and parameter guidance arrive only after that enumeration. It is information-rich but not tightly structured, so it lands at adequate rather than efficient.

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?

An output schema exists, so the description need not detail return shape — and it briefly does anyway. With annotations covering the safety profile, a single optional enum parameter, and no nesting, the agent has enough to invoke this correctly. Remaining minor gap is no explicit mention of sibling routing tools.

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% and the enum values are self-describing, which sets the baseline at 3. The description adds value by explaining the effect of the parameter: supplying `for` narrows the result to the single server that fulfils the need, and omitting it (per schema) yields all servers. That routing behavior is meaningful context beyond the schema text.

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 states a concrete action and resource: it enumerates INITE's other MCP servers and returns the material needed to add each one to the current client. It also distinguishes itself from siblings by framing itself as the escalation path when the current server cannot satisfy the request. The phrasing is muddled in places (e.g. 'its signed-in door'), but the core purpose is recoverable.

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?

It gives an explicit trigger condition: 'Call it when the person wants something this server does not do', plus the mechanics of 'give `for` to get the one server that does it'. No alternative sibling is named (e.g. match_mcp/match_tools), so it falls short of a full when/when-not comparison, but the intent is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/openWorld/non-destructive, so the safety burden is covered. The description adds genuinely useful behavioral context beyond them — no account needed for the identity-reading-free version, and signed-in results derive from the latest finished audit covering answer engines.

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 main clause leads with the deliverable ('the fix plan...most important first') so it is well front-loaded. The core is one very long, densely-comma'd sentence, which is efficient but slightly hard to scan; the account/audit note is a reasonable trailing fragment.

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?

With an output schema present, return values need not be re-explained, yet the description covers the fix contents, fallback modes (anonymous vs signed-in), and the source of data. Nothing essential for calling it correctly is missing.

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 url and limit are already fully documented in the schema (including the default of 12 and the 1-30 range). The description's 'pages it applies to' and 'most important first' phrasing adds only marginal meaning beyond the schema, so the baseline 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 states a concrete verb+resource ('the fix plan for a site's AI visibility, most important first') and enumerates exactly what each fix contains (what to change, why it matters, point recovery, pages, paste-ready snippet). This is specific enough that an agent can distinguish it from analyze_site, get_analysis, or visibility_history on purpose alone.

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?

It clearly gives operating context: usable free with no account versus signed in being built from the latest finished audit of that site. That tells the agent when the richer result applies. It does not, however, name or contrast with sibling tools (e.g. get_analysis vs visibility_history), so it stops short of explicit alternative routing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds genuinely new behavioral context: it is free, requires no model, spends no check, and only reads prior measurements — useful cost/side-effect disclosure beyond the structured hints.

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?

Front-loads the purpose ('how a site's AI visibility reading has moved over time') before the parenthetical detail and the free/no-check note. Dense with semicolons but every clause earns its place; no filler.

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?

An output schema exists, so return values need not be spelled out. The description covers what the tool yields, the historical scope, and the zero-cost behavior; the only gap is explicit routing against sibling measurement tools, which is minor given the 'reads what was already measured' framing.

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 is a single required parameter with 100% schema description coverage, and the description adds no URL syntax or format beyond what the schema states. Per the baseline rule, a 3 is appropriate when the schema fully documents the lone parameter.

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?

States a specific resource (a site's AI visibility reading) and explicitly scopes it to movement over time, listing the concrete weekly data points (identity score, crawlers, llms.txt, Organization schema, top fix). This distinguishes it conceptually from fresh-measurement siblings like analyze_site, though it never names a sibling directly.

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 clause 'Free, no model, and no check is spent: it reads what was already measured' implies this is for retrieving existing history rather than triggering a new run, which guides usage. However it never explicitly contrasts with alternatives such as analyze_site or visibility_fixes, leaving the when-to-use decision largely to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.