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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context beyond annotations: it targets the caller's own subscription, works with any valid key, consumes no audit quota, and details the exact return fields including a plain-language summary and Pro requirements. This gives the agent a clear model of what calling the tool will do and what it won't do.

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 well-structured: it opens with the core purpose, follows with explicit usage triggers, then covers behavior and return values in one efficient list. Every sentence adds useful information, and the trigger phrases are front-loaded for quick comprehension.

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 zero-parameter, read-only subscription status tool, the description is complete. It covers purpose, applicable triggers, side-effect-free behavior, and what the caller receives in the response. The output schema exists, but the description still usefully summarizes the meaningful return fields without being redundant.

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 tool has zero parameters, so the baseline is 4. The description still clarifies that the tool inherently operates on 'the caller's own' subscription, which is meaningful contextual semantics even without input parameters.

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 ('Check') and a precise resource: the caller's own Website Auditor subscription standing. It clearly distinguishes this from sibling tools by naming the exact user questions it answers ('am I on Pro,' 'is my trial still active'), so the agent can select it unambiguously.

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 gives explicit when-to-use guidance with concrete trigger phrases and even 'before suggesting an upgrade.' It also clarifies that it 'Works with any valid API key and consumes no audit quota,' which helps the agent decide whether this tool is appropriate in edge cases like locked tools or trial inquiries.

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?

Beyond the readOnly/openWorld annotations, the description richly discloses quota consumption per uncached competitor, partial-audit behavior with skipped lists, the guarantee that competitors are never silently dropped or scores invented, and over-quota error behavior with reset time. Subscription requirements are also clearly surfaced.

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 dense but every sentence earns its place: purpose, trigger phrasing, return behavior, quota edge cases, and subscription prerequisite. It is front-loaded with the core purpose and avoids 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?

Given the tool's complexity and the existing structured fields, the description covers purpose, input semantics, quota behavior, error handling, prerequisites, and fallback actions. The output schema handles return-value structure, so no additional detail is required.

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?

Even though schema coverage is 100%, the description adds meaningful parameter context: competitors consume quota when not cached, and business_location is explicitly applied to the site AND every competitor to avoid mixed-market comparisons. This exceeds the schema-only meaning.

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 and resource: 'Compare a website's AI visibility head-to-head against named competitors.' It also gives concrete user phrasings that trigger this tool, which clearly separates it from related siblings like get_ai_visibility or get_benchmark.

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 provides explicit when-to-use triggers with example questions and explains a fallback path (call get_sample_audit if no subscription). However, it does not explicitly state when not to use this tool or name alternative sibling tools beyond the sample-audit fallback.

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?

The annotations already cover non-destructive read-only behavior. The description goes beyond them by disclosing the paid subscription requirement, the free-trial terms, and that the tool returns valid JSON-LD. It doesn't contradict the annotations and adds the non-obvious prerequisite.

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 front-loaded with the core purpose and trigger phrases, then gives return expectations and the subscription/fallback context. It is a bit longer than strictly necessary because of the trial payment details, but each sentence 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?

Given only two parameters, an output schema, and annotations covering safety, the description covers the required context: what it does, when to use it, what it returns, and what to do if the user isn't subscribed. Nothing critical is missing for correct tool selection.

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 documents both parameters with descriptions, including the enum options and a domain example, so schema coverage is 100%. The description doesn't add parameter-specific meaning beyond what the schema provides, which lands it at the baseline.

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 and resource: it generates ready-to-paste JSON-LD structured data tailored to a website. It also names the exact user triggers ('schema,' 'structured data,' 'JSON-LD') and distinguishes this tool from audit/report siblings.

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 explicitly says when to use the tool ('when someone asks for...') and provides a clear alternative path: if the user lacks a paid subscription, call get_sample_audit first. This is direct, actionable routing guidance.

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 mark readOnly/openWorld/non-destructive; the description adds substantial behavioral context: the subscription/payment gate, null-vs-absent semantics for sources, null trend with trend_note explanation, and the name_warning caveat that must be relayed. No contradiction with 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 description is front-loaded and logically ordered, but it is long and repeats output details that an output schema would already document. Some subscription marketing detail (payment method, trial terms) could be trimmed without losing invocation guidance.

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?

Despite its length, it covers all operational context an agent needs: when to call it, the subscription prerequisite and fallback, per-engine output, sources/trend null behavior, and the name_warning caveat. With an output schema present, nothing essential 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 description coverage is 100%, so the schema carries parameter semantics. The main description mostly restates the business_name verification caveat and does not add new parameter meaning; it links name_warning to the business_name parameter but that link is already implied by the 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 opening sentence states a precise verb, resource, and time scope: 'Check how visible a website is to AI assistants right now.' It then names the exact outputs (0–100 score, ChatGPT/Perplexity/Claude/Gemini breakdown, top competitor), making the tool's role unambiguous and distinct from report/monitoring siblings.

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?

Gives explicit trigger phrases ('does ChatGPT recommend this business', 'what's my AI visibility') and an explicit alternative: call get_sample_audit when no subscription exists. It does not, however, contrast with other audit/monitoring siblings (e.g., get_monitoring_status, get_report), so the when-not-to-use guidance is incomplete.

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 mark the tool as read-only and non-destructive, and the description adds a crucial behavioral constraint: the tool requires a Website Auditor subscription, including free-trial details and the fact that payment information is needed upfront. It also discloses that results are backed by aggregated audit data.

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?

Every sentence contributes a distinct piece of information: what the tool does, when to use it, how the data is derived, the subscription requirement, and the fallback path. The purpose is front-loaded, and no unnecessary boilerplate is present.

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-value details are not the description's job. The description covers the prerequisite (subscription), the fallback flow (get_sample_audit), the use-case signals, and the underlying data source. Nothing critical is missing for an agent to decide when to call this tool.

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?

All three parameters already have schema descriptions, so the baseline is 3. The tool description does not add much parameter-level detail beyond implying that geo and industry are optional overrides used for benchmarking context, which the schema already states.

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 opens with a specific verb and object: 'Benchmark a website's AI visibility against its industry and location,' and clarifies that the user wants percentile/peer context rather than an absolute number. This distinguishes it from tools like get_ai_visibility and compare_competitors by making the benchmark scope (industry/geo) explicit.

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 gives explicit trigger phrases ('how do I compare to others in my space,' 'is this a good score for my industry') and tells the agent to call get_sample_audit first when the user lacks a subscription. This is clear, actionable routing guidance with a named fallback.

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 only convey read-only and non-destructive hints. The description adds substantial behavioral context: changes are only measured between same-question snapshot pairs, competitor_changes/new_issues/resolved_issues are always empty, no-pair cases explain why and report re-baseline dates, and the series definition is spelled out. No contradiction with 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 description is a dense, single-paragraph wall of text with extremely long, convoluted sentences, especially the series-definition clause. Although the first sentence is front-loaded, the subscription/trial details and nested conditional logic make it hard to scan and substantially exceed what is needed for a 2-parameter tool.

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 an output schema exists, the description still explains return semantics (overall and per-engine score changes, always-empty fields), error behavior when no valid snapshot pair exists, subscription requirements, and the fallback to get_sample_audit. An agent has everything needed to invoke and interpret this 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 description coverage is 100%, so both domain and since are already documented in the schema. The description reinforces that the domain must be tracked and that 'since' relates to snapshot pairing, but it adds no new syntax or format details 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?

The opening sentence states a specific verb and resource: 'Report what changed in a website's AI-visibility score, only between two snapshots that asked the same question.' This clearly distinguishes the tool from siblings like get_ai_visibility (current value) and compare_competitors (competitor comparisons).

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 explicitly says when to use it ('Use this when someone asks...') with concrete example queries, and names preconditions and alternatives: domain must be tracked (see track_site) and non-subscribers should call get_sample_audit first. This gives an agent clear selection and fallback logic.

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?

Beyond the readOnlyHint/openWorldHint annotations, the description reveals how the plan is grounded (citation evidence from sources marked yours/competitor/third_party), the fallback behavior when no citations exist, and the subscription requirement. It even specifies the prerequisite call to get_sample_audit for non-subscribers, providing behavioral context annotations cannot convey.

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?

Though fairly long, every sentence earns its place: purpose, use cases, grounding mechanism, fallback, parameter steering, subscription prerequisite, and alternative action are all present without filler. The most important information is front-loaded, and the subscription note is placed logically at the end.

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 description covers the main purpose, when to use it, how the plan is grounded, what to do without citations, how to use parameters, and the subscription gate. Since an output schema exists, return-value details are already provided elsewhere, so nothing essential 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 schema already documents all four parameters. The description adds modest interpretive value by explaining that focus/constraints 'steer' the plan and prior_plan is for refining rather than starting over, but it does not provide substantial new detail beyond the schema's own parameter 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?

The description opens with a specific verb and resource: 'Build a written go-to-market plan from a website's latest audit.' It also provides concrete user-phrase examples ('what should I do about my AI visibility') and clarifies that competitor sources inform but never become placement targets, which distinguishes this tool from recommendation or report tools.

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 explicitly states when to use the tool with quoted user requests and gives situational guidance: use focus/constraints to steer, prior_plan to refine, and call get_sample_audit first if the user lacks a subscription. It clearly tells an agent when to use this tool versus a 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds substantial behavioral context: the subscription requirement, the complex series logic for AI-visibility scores, the fact that change fields are always empty, and the fallback to get_sample_audit. No contradiction with 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 description is very long and dense, especially the series logic explanation, which is a run-on sentence that is difficult to parse. It is front-loaded with purpose and usage, but the level of detail is excessive for a zero-parameter tool and could confuse agents. The structure is logical but not concise.

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 description covers purpose, usage scenarios, return details (per-domain info, series logic, scheduled runs, changes), the subscription requirement, and the fallback to get_sample_audit. An output schema exists, so return values need not be spelled out, but the description still provides enough context for correct invocation.

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 tool has zero parameters, so the schema trivially covers 100%. The description adds no parameter information because none exists, and the baseline for 0 params is 4. No further compensation needed.

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 opens with a clear verb+resource: 'Get a glanceable summary of monitoring status across all tracked websites.' It also lists concrete user queries that should trigger this tool, distinguishing it from siblings like get_changes and get_sample_audit by context and behavior.

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 explicitly states when to use the tool (specific queries) and gives a clear exclusion: if the user lacks a subscription, call get_sample_audit first. It also references get_changes for a related but distinct use case, providing both when-to-use and when-not-to-use guidance.

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?

Beyond the readOnly/openWorld/destructive annotations, the description discloses the Website Auditor subscription requirement with trial terms, states the return shape as 'ranked actions with expected impact,' and prescribes the get_sample_audit fallback. No contradiction: readOnlyHint=true aligns with a read operation.

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?

Purpose and usage triggers are front-loaded, followed by return shape and entitlement details in order of importance. The subscription/trial sentence is dense but each clause earns its place by telling the agent whether to call the tool or divert to get_sample_audit; slightly verbose but not bloated.

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 1-parameter tool with an output schema and read-only annotations, the description covers the operational essentials: usage triggers, return content, entitlement gating, and fallback routing. The only ambiguity is whether a prior run_audit is a prerequisite or whether the tool works standalone from the trigger phrases alone.

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 the single 'domain' parameter, so the schema already documents its meaning and format. The description adds no parameter-level detail, but none is needed for a self-explanatory domain string; 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 opens with a specific verb and resource: 'Get specific, prioritized fixes to raise a website's AI visibility and audit scores.' The title 'Prioritized fixes' and the phrase 'ranked actions with expected impact' clearly distinguish it from siblings like run_audit, get_changes, and get_gtm_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 usage triggers are listed ('how do I fix this,' 'what should I change,' 'how do I improve my AI visibility,' or after an audit surfaces issues), and the subscription requirement routes to the correct alternative: 'if the user doesn't have one, call get_sample_audit first.' This gives the agent both when-to-use and when-to-fallback guidance.

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 declare readOnlyHint=true and destructiveHint=false; the description adds the subscription prerequisite, trial terms, and the fallback path to get_sample_audit. It also explicitly states what is returned, going beyond annotations and schema to inform callers of gating and side expectations.

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 front-loaded with the core purpose, followed by use cases, then requirements. Every sentence earns its place: output, when to use, subscription prerequisite, and fallback action. There is no redundant filler or vague wording.

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 and a single parameter fully described, the description covers all decision-critical context: when to use, what prerequisite applies, and what to do when it is not met. Nothing needed for correct invocation 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 description coverage is 100%, and the sole 'domain' parameter already has a clear schema description ('The website domain, e.g. "example.com"'). The description's phrase 'for a website' adds little beyond the schema, so 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 states a specific verb and resource: 'Get a shareable report URL and the embeddable "Audited by Website Auditor" badge snippet for a website.' It clearly differentiates the tool from siblings like run_audit or get_sample_audit by naming the exact output (link + HTML badge snippet).

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 when-to-use guidance is present: 'Use this when someone wants to "share," "export," "send a client," or "embed" the audit result.' It also provides an explicit alternative and condition: if the user lacks a subscription, call get_sample_audit first. This is direct when/when-not guidance.

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 indicate read-only and non-destructive behavior, and the description goes further by disclosing that no API key or setup is required, the data is fixed for example.com, and the response is clearly marked as a sample. It also explains the return shape: scored summary, per-test results, and AI-visibility breakdown across specific models. This is thorough behavioral context 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 description is detailed but each sentence contributes: it states the purpose, the trigger scenarios, the output contents, and the critical limitation that it never audits the user's own site. There is slight redundancy between 'no API key required' and 'INSTEAD of refusing when no API key is configured,' but overall it is well organized and 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?

Given zero parameters and an existing output schema, the description is remarkably complete: it explains when to use the tool, what data it returns, how that data is structured, that it is sample data, and that real audits require a subscription. Nothing an agent needs to decide whether to call this tool 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?

The tool has zero parameters, so there is no schema burden to compensate for. The description adds helpful invocation context by stating that no API key or setup is needed, which reinforces that the tool is callable without prerequisites. This meets the baseline for parameterless tools.

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 and resource: 'Show a complete sample Website Auditor report.' It clearly distinguishes itself from a real audit by emphasizing that it returns fixed sample data for example.com and never the user's own site. This leaves no ambiguity about what the tool does.

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 gives explicit trigger scenarios such as 'try it,' 'see a demo,' and 'show me what this does,' and explicitly says to use it instead of refusing when no API key is configured. It also states the key negative condition: never use it for a user's real domain. It does not explicitly name an alternative tool like run_audit, but it makes the boundary between sample and real subscriptions 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 readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it returns cadence and active state, slots used/remaining out of 5, and importantly discloses the subscription requirement and trial terms. It also explains the fallback behavior (call get_sample_audit). This goes 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 description is a bit long but every sentence earns its place: the first sentence states the core function, the second gives example queries, the third details the return values, and the fourth explains the subscription requirement and fallback. It is front-loaded with the primary purpose. Slightly verbose but not 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?

For a parameterless list tool with an output schema and read-only annotations, the description is complete. It covers what the tool does, when to use it, what it returns, the subscription prerequisite, and the alternative path. An agent has everything needed to decide whether to call it and 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?

The tool has zero parameters, so the schema provides no parameter semantics. The description compensates by explaining what the tool returns (each tracked domain with cadence, active state, slots used/remaining), which is the relevant semantic content for a parameterless list tool. Baseline 4 for 0 params 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 lists websites currently being monitored for AI visibility, with a specific verb ('List') and resource ('websites currently being monitored'). It also distinguishes itself from siblings by mentioning the scheduling aspect and the specific output (cadence, active state, slots used/remaining).

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 explicit when-to-use guidance with example user queries ('what am I tracking,' 'which sites am I monitoring,' 'how many monitoring slots am I using'). It also gives a clear alternative: if the user lacks a Website Auditor subscription, call get_sample_audit first. This is strong routing guidance.

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?

Beyond the readOnly/opennWorld/dstructive annotations, the description discloses the paid-subscription requirement, trial terms, the scored-summary + report-link return shape, and the `name_warning` caveat the agent must relay. It also clarifies this is a one-time audit rather than ongoing monitoring, which is 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?

Every sentence adds distinct value: purpose, trigger use cases, return format, what is not returned, caveat, and billing/alternative. Core purpose is front-loaded in the first sentence and the operational notes are grouped logically, with no filler or redundant schema 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?

The output schema covers return structure/fields, so the description only needs to cover invocation, subscription gating, caveat handling, and sibling routing — and it does all four. For a billing-gated tool with many siblings, nothing essential 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 schema already explains domain, business_name, and business_location thoroughly, including the unverified-name caveat and location-detection behavior. The description adds little beyond reinforcing the `name_warning` caveat, so the 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?

Opens with a concrete verb and resource: 'Run a full one-time audit of a website' and lists exactly what is covered (AI visibility, SEO, security headers, broken links, performance). It also differentiates itself from get_ai_visibility by clarifying this is the complete-report tool, which makes sibling distinction immediate.

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 spells out trigger phrases ('audit,' 'scan,' 'check,' 'review') and the complete-report use case. It also routes non-subscribers to get_sample_audit and states that cited-source evidence belongs to get_ai_visibility, not this tool — so the agent knows both when and 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 only mark this as non-read-only and non-destructive; the description adds important behavioral context: monitoring continues on a schedule, it establishes history for get_changes, and a paid subscription is required. It also lays out the 7-day free trial terms, so an agent understands the commercial side effect before calling.

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 opening sentence names the action immediately, followed by precise usage guidance and prerequisite logic. Each sentence adds a distinct piece of information; no filler. The long subscription clause is justified because it determines whether the agent should call a different tool.

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?

Combined with the output schema and annotations, the description covers purpose, when to use, subscription gate, fallback tool, and relationship to get_changes. Nothing an agent needs to decide between this and siblings 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 description coverage is 100%, so the baseline is 3. The description doesn't add much parameter-level detail; it only hints at scheduling and stopping, which the schema's enabled/cadence docs already cover. No compensation needed, but no extra value either.

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 action ('Start (or stop) ongoing monitoring') on a clear resource ('a website's AI visibility on a schedule'), and distinguishes itself from a one-off check. It also explicitly ties to sibling get_changes, making its role in the workflow unmistakable.

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?

Gives explicit trigger phrases ('monitor,' 'track,' 'watch,' 'get alerted about') and contrasts with 'rather than a one-off check.' It also provides a conditional alternative: if no Website Auditor subscription, call get_sample_audit first. This is strong, actionable 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 flag destructiveHint=true, and the description builds on that by disclosing idempotence, the return value (number of slots freed), and the subscription prerequisite. It also explains the fallback behavior for users without a subscription, which is valuable beyond the structured 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 description is longer than average, but every sentence contributes: purpose, trigger phrases, idempotence, return value, subscription prerequisite, and alternative tool. The main action is front-loaded, and only the subscription/trial detail adds mild verbosity.

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 destructive, paid-gated tool, the description covers when to use it, what to tell the user about subscription, what happens if the site is not currently tracked, and what the result will be. An output schema exists and the description also mentions the return value, so no critical context 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?

The input schema has 100% coverage for the single required parameter, domain, with a clear example. The description does not add much domain-specific semantic detail beyond the schema, but none is needed given the schema's completeness.

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 opens with a specific verb and resource: "Stop ongoing monitoring of a website's AI visibility." It distinguishes itself from siblings like track_site and list_tracked_sites by clearly stating the reverse operation, and it provides natural-language triggers for when a user wants this action.

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 explicitly says when to use the tool (“stop tracking,” “unmonitor,” “stop watching,” “remove” a site, free a slot) and provides an explicit alternative path: call get_sample_audit first if the user lacks a subscription. This is strong routing guidance.

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