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

No annotations provided, so description carries full burden. It explicitly lists outputs (aio_present, answer text, cites, top organic results) and implies a read-only operation. No contradictions or hidden effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with purpose, followed by output summary and use case. No redundancies or 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?

Explains return values (helped by output schema existence) but does not clarify how optional parameters like location or hl affect AIO retrieval. Lacks details on required vs optional inputs beyond the schema.

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 0%, but description only mentions 'query' implicitly via 'Run a Google search' and provides no details on location, hl, gl, or google_domain. This fails to compensate for the low schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states 'Run a Google search via SerpAPI and parse the AI Overview block,' specifying the action and resource. It also describes return values and use case ('track which pages Google's generative answers actually source'), effectively distinguishing it from siblings like claude_query or gemini_query.

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 a use case ('Use this to track which pages Google's generative answers actually source') but does not exlicitly state when to avoid it or compare to alternatives like aio_citation_check or other search tools.

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?

No annotations provided, so description carries full burden. It discloses the report type (AIO fire-rate and citation share) and context (Google AI Overviews). Does not mention rate limits or execution characteristics, but overall behavior is well-understood.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences: core purpose, sibling context, and usage guidance. Front-loaded and efficient with no wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no annotations and 0% schema coverage, the description covers purpose, sibling differentiation, and a usage workflow. Output schema exists, so return details are not needed. Complete for a batch query 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?

Schema coverage is 0%, but description names 'batch of queries' and 'target_domain' which map directly to the two parameters. The description adds meaning beyond the schema by clarifying that queries are batched and the domain is the target.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the tool reports AIO fire-rate and citation share for target_domain from Google's on-SERP AI Overviews. It distinguishes from sibling multi_llm_citation_check by specifying it's the GEO companion for AIO specifically.

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 says 'Run weekly and snapshot to snapshot_serp_aio to track AIO visibility over time', providing a clear usage pattern. Also contrasts with multi_llm_citation_check to guide when to use which.

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 full burden and does a good job: it discloses the optional render path, its extra dependency, the fact that non-JS rendering is flagged, and the shape of the returned report plus score. It stops short of stating explicitly that the tool is read-only or whether network access/auth is involved.

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 definition is front-loaded with the core purpose, followed by the render caveat, return summary, and examples. The return-value enumeration is somewhat lengthy given that an output schema exists, which keeps it from being maximally tight.

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 two-parameter audit tool with an output schema, the description supplies the critical operational detail: input forms, render behavior and dependency, and the presence of an overall score and findings. Only an explicit statement of read-only behavior or side-effect profile 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 0%, so the description must compensate, and it does: source is described as a local file path or http(s) URL, and render is explained as running the page after JavaScript with a named installation prerequisite. Concrete example calls further pin down the expected argument format.

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 first line states a specific verb and resource ('Audit a single page') and immediately distinguishes the accepted input forms (local file path or http(s) URL). The single-page scope also separates it from the sibling audit_site tool without ambiguity.

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 establishes the single-page context and explains when to set render=True, including the prerequisite extra and playwright install. It does not explicitly name audit_site as the alternative for whole-site auditing, so the routing guidance is clear but not complete.

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?

Without annotations, the description carries the full burden. It discloses recursive behavior and the return of per-file scores, aggregate summary, and top opportunities. It does not mention authentication needs or rate limits, but the read-only nature is implied. Overall, it gives sufficient behavioral context for the agent.

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 only three sentences, each adding value: scope, return values, and use case. No unnecessary words; it is concise 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 the tool has an output schema, the description need not detail return values, but it still gives a high-level summary. It covers purpose, behavior, and usage context completely for an agent to decide when to invoke it.

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 0%, so the description must compensate. It implicitly explains the 'folder' and 'pattern' parameters by stating 'every HTML file under a folder,' but the 'limit' parameter is not mentioned. Thus, it adds some meaning but not complete compensation.

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 recursively audits every HTML file under a folder, distinguishing it from audit_page (single page) and other sibling tools. The verb 'audit' and resource 'every HTML file under a folder' are specific and 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 explicitly notes 'Useful as the first call against a content directory to spot the worst offenders quickly,' providing clear when-to-use guidance. While it does not explicitly say when not to use it, the sibling context implies using audit_page for single pages.

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?

No annotations are provided, so the description carries the full burden. It only states what the tool retrieves but does not disclose behavioral traits such as authentication needs, pagination, or data freshness. Minimal 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 a single, concise phrase with no wasted words. However, it is slightly terse and could benefit from a bit more structure.

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?

Although an output schema exists (which may explain return values), the description lacks context about the scope of issues (e.g., timeframe, severity) and fails to make the tool self-contained. Given the low parameter count, more detail is expected.

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 has one required parameter (site_url) with 0% description coverage. The description does not add any meaning to this parameter—no format, examples, or constraints are mentioned.

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 it retrieves crawl errors, blocked URLs, and DNS issues from Bingbot. It uses specific terms like 'crawl errors' and 'Bingbot', but does not differentiate from sibling tools like bing_url_info or bing_page_stats.

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?

No guidance on when to use this tool over alternatives. The sibling list includes many Bing-related tools, but the description offers no hints about scenarios or exclusions.

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?

No annotations are present, and the description provides minimal behavioral context beyond 'list all sites'. It does not disclose whether the operation is read-only, requires specific permissions, or has rate limits. For a tool with no annotations, the description should offer more behavioral detail.

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 sentence that is perfectly concise and front-loaded. Every word is essential, and there is no wasted text.

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 the tool has no parameters and an output schema exists, the description is adequate. It clearly states what the tool does, but could optionally add context about the output format or typical use cases. However, for a simple listing tool, it is nearly complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the schema coverage is 100% (empty schema). According to the guidelines, 0 parameters defaults to a baseline score of 4. No additional parameter information is necessary.

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 all Bing-verified sites for the API key owner. It uses a specific verb and resource. Although it doesn't explicitly differentiate from sibling tools like 'bing_crawl_issues' or 'bing_page_stats', the name and description make the purpose distinct.

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?

No usage guidelines are provided. The description does not mention when to use this tool versus alternatives, nor does it specify any preconditions or contexts where it is appropriate or not.

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 full burden of behavioral disclosure. It only implies a read operation via 'stats', but does not explicitly state if it is read-only, whether it requires authentication, or any side effects. Significant transparency gaps remain.

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 concise with only one sentence, which is efficient but lacks necessary detail. It earns its place by being short, but the brevity comes at the cost of clarity and completeness. A middle score is appropriate.

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 simple input schema and presence of an output schema, the description could be sufficient, but it fails to explain what the tool returns or how to interpret the results. The AI is left to guess from the tool name and siblings, which is not complete for reliable use.

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 0%, meaning the schema provides no explanation for the 'site_url' parameter. The description does not compensate by explaining what format or value 'site_url' expects (e.g., full URL, domain). This leaves the AI with insufficient guidance to correctly invoke the tool.

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 'Per-page stats from Bing Webmaster', which identifies the resource (Bing Webmaster) and the nature of the data (stats per page). However, it lacks a specific action verb and does not clarify what kind of stats (e.g., impressions, clicks). This vagueness makes it harder for an AI to distinguish from siblings like 'bing_query_stats'.

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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, context, or scenarios where this tool is appropriate or inappropriate. The description gives no hints about usage context.

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 description reveals that results are limited to the last 6 months and requires the site_url to match Bing's verified format. However, with no annotations provided, it does not address read-only behavior, authentication needs, rate limits, or pagination. The output schema exists but is not referenced in the description.

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 with two sentences. It front-loads the core purpose and follows with the critical parameter requirement. Every part is necessary and there is no 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 the tool's simplicity (1 required parameter, output schema present), the description adequately covers purpose and parameter constraint. It lacks guidance on data representativeness (e.g., is it aggregated daily?) but is sufficient for an agent to use 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?

The input schema has no description for site_url (0% coverage). The description compensates by explaining that site_url must match Bing's verified format with an example. No other parameters exist, so this adds necessary context beyond 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 description clearly states the tool retrieves 'Last-6-months query stats from Bing Webmaster' including clicks, impressions, and position. It distinguishes from siblings like bing_page_stats (page-level) and bing_crawl_issues (issues) by specifying the kind of data and time range.

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 the tool is for historical query performance data over the last 6 months, but does not explicitly mention when to use it compared to alternatives such as bing_page_stats for page-level metrics or gsc_performance for Google. No exclusions or alternative tools are named.

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 must disclose behavioral traits; it mentions the daily quota but does not explain implications of exceeding it, auth requirements, or what 'fast crawling' entails. It provides minimal transparency beyond the quota.

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, fitting one sentence and a parenthetical. It is well-front-loaded but could benefit from slightly more structure or detail without losing brevity.

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 submission tool with an output schema, the description covers basic usage but lacks completeness regarding error states, authentication, or post-submission behavior. It is minimally adequate but has clear gaps.

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 two parameters with 0% description coverage, and the description adds no explanation of 'site_url' or 'url' beyond their names. This forces reliance on inference, which is insufficient for correct invocation.

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 ('Submit') and the resource ('URL for fast crawling'), making the tool's purpose immediately obvious. It effectively distinguishes itself from siblings through the action of submitting to Bing, though not explicitly naming alternatives.

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 mentions a daily quota, providing some context for usage, but does not guide on when to use this tool versus alternatives like indexnow_submit_url. It lacks explicit when-to-use or when-not-to-use instructions.

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 full burden for behavioral disclosure. It only states the tool provides index status and crawl info, but does not clarify if it is read-only, whether it triggers API calls, rate limits, or what happens if the URL is not found. Minimal transparency for a mutation-free information retrieval 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 a single, front-loaded sentence that immediately states the tool's core function. Every word earns its place, with no redundancy or extraneous information.

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?

While the tool is simple (2 params, no nested objects), the description lacks context about how it fits among 20+ sibling tools. An agent would not know when to choose this over similar tools like bing_page_stats or gsc_inspect_url. The output schema exists but does not mitigate the lack of usage context.

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 has 0% description coverage for its two required parameters (site_url, url), and the description adds no semantic information about them. It does not explain expected format (e.g., full URL vs domain), relationships between parameters, or valid values. The description fails to compensate for the schema's deficiency.

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 provides 'Index status + crawl info for a single URL on Bing.' This specifies the verb (get/report), the resource (URL on Bing), and the scope (single URL), distinguishing it from sibling tools like bing_page_stats (page-level metrics) or bing_crawl_issues (crawl issues).

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?

No guidance is provided on when to use this tool versus alternatives. For example, it does not explain when to prefer this over bing_page_stats or bing_crawl_issues, nor does it mention prerequisites or limitations. The description is purely functional.

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 must carry the full behavior burden. It usefully discloses the plan requirement and API key env var (GEOSEO_BRAVE_API_KEY) and describes the return shape, but says nothing about rate limits, latency, failure modes, or quota costs.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three compact sentences, front-loaded with the core action and return shape, followed by differentiation and the access requirement. No 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?

An output schema exists, so return values needn't be re-explained, and the auth requirement is covered. However, the absence of any parameter guidance and lack of cost/limit behavior leaves clear gaps for a query tool with three undocumented parameters.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for all three parameters. It says nothing about 'question', 'country', or 'language' – no expected formats, code conventions, or defaults – leaving every parameter undocumented.

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 ('Ask Brave's AI Answers, grounded in Brave Search') and the return shape (answer + cited URLs). It also distinguishes itself from similar query siblings like perplexity_query and openai_query by noting Brave's independent web index, though it never names those siblings explicitly.

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?

Implies usage ('a useful extra signal next to Google/Bing-backed engines'), giving an agent a rough sense of when to prefer it. But it never explicitly names alternatives such as perplexity_query or multi_llm_query, nor does it state exclusions or 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?

No annotations are provided, so the description must disclose behavioral traits. It mentions 'server-side web search' and the return format, but it does not state whether the operation is read-only, destructive, or any side effects, nor does it mention authentication, rate limits, or error conditions.

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 conveys the core purpose and output without any extraneous words. It is front-loaded with the action and resource.

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 having 4 parameters and no annotation, the description lacks details on parameter usage, return format beyond 'answer + cited URLs', and behavioral context. The output schema exists but is not detailed in the prompt, and the description does not compensate for the missing annotations.

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 0% description coverage and the description does not explain any parameters. While the schema defines parameters like question, model, system_prompt, and max_tokens, the description adds no meaning beyond the raw schema names, leaving the agent without guidance on how to set them.

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 identifies the verb 'ask', the resource 'Claude (with server-side web search)', and the output 'answer + cited URLs'. It distinguishes this tool from siblings like gemini_query or openai_query by specifying both the model and the web search capability.

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 usage for asking questions with web search, but it does not provide explicit guidance on when to use this tool versus alternatives such as gemini_query or perplexity_query, nor does it mention 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?

With no annotations, the description carries the full burden and does so well: it discloses the HEAD-with-GET-fallback check method, deduplication of unique URLs, the exact result groupings, the per-link page attribution and suggested action, and the caching rules (timeouts never cached, cache_days=0 forces refresh). It omits network-cost/rate-limit implications and permission needs for a tool that makes many outbound requests.

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 purpose, then method, then result structure, then parameter semantics. Every sentence adds information an agent needs; the parenthetical listing skipped schemes and the caching caveat both earn their 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 return shape needn't be explained, yet the description helpfully previews the result groupings. For a no-annotation network tool it is nearly complete, but it lacks any note on outbound-request volume, throttling expectations, or failure modes for the folder itself.

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 0% across 8 parameters, so the description must compensate. It clearly explains site_host (with an example), cache_days (0 = fresh check), and implies timeout behavior, but pattern, max_urls, include_ok, and concurrency are never mentioned, leaving half the surface undocumented.

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 first sentence names a specific verb (find) and a precise resource/scope (dead, redirected, or flaky outbound links across a folder of HTML). It clearly separates this tool from siblings like internal_link_graph or audit_page by emphasizing external links only.

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 establishes the operating context well: it works on a folder of HTML files, collects only external <a href> links, and skips mailto/tel/javascript/anchors. It also explains how site_host converts own-site absolute links to internal so they're skipped. It never explicitly names an alternative tool or states when not to use it, so it falls 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?

No annotations exist, so description must disclose behavioral traits. It reveals Google Search grounding and the AI Overviews proxy nature, which is key behavioral insight beyond a simple query. However, details like idempotency, rate limits, or default model behavior are omitted.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences concisely cover purpose, grounding, and the unique value proposition. Front-loaded with the main action, and no fluff.

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 3 parameters and an output schema, the description only addresses the required 'question' parameter. The optional parameters are undocumented, leaving gaps for effective use. The output schema likely covers return values, but the description could hint at optional params.

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 0%, yet the description only mentions 'a question' and ignores the optional 'model' and 'system_prompt' parameters. No parameter details are provided, failing to compensate for the schema gap.

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 asks Gemini with Google Search grounding a question and returns answer with cited URLs. It specifies the verb 'Ask', the resource 'Gemini (with Google Search grounding)', and distinguishes from sibling tools like claude_query and openai_query by highlighting the AI Overviews proxy use case.

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 use when seeking grounded Gemini answers or AI Overview insights but lacks explicit when-not to use or alternative suggestions. Sibling tools cover other LLMs, so context is provided, but no direct guidance on choosing this over others.

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 discloses key behaviors: reading HTML files, extracting title/meta description, grouping by URL prefix, and outputting Markdown. It does not cover error handling or side effects, but sufficient for non-destructive file generation.

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 well-structured: a one-sentence summary, a brief background on llms.txt, the basic operation, and a parameter explanation. No superfluous content.

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 presence of an output schema and the description's coverage of core functionality (grouping strategy, output format), it is fairly complete. Minor omissions: default limits and pattern are not mentioned, but schema supplies those.

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 0%, yet description only explains 'section_strategy' (with two modes). Critical parameters like 'folder', 'site_url', 'limit', and 'pattern' are not described, leaving agents to infer from names alone.

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 purpose: 'Generate a draft llms.txt from a folder of HTML pages.' It explains the standard and distinguishes from sibling 'validate_llms_txt' by focusing on generation.

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 context on when to use (initial generation) and explains the section_strategy options. It does not explicitly mention alternatives or when not to use, but the sibling list implies 'validate_llms_txt' is for post-generation checking.

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 full burden and thoroughly discloses behavior: it is safe (no side effects), returns a dict with structured output (configured: bool and message), and reports configured and reachable status.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences with no wasted words, front-loaded with the purpose, and efficiently conveys all necessary information.

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 stateless, no-parameter tool with an output schema, the description is complete: it describes the output format and usage context, leaving no gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so the description adds value by explaining the return structure (dict keyed by engine name) beyond the empty schema, which is appropriate for 0-param 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 clearly states the tool reports which engines are configured and reachable, using the verb 'report' and specifying the resource. It distinguishes from siblings like 'list_llm_engines' by focusing on configuration and reachability status.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states 'Always safe to call' and recommends using it as the first call in a session to know what's available, providing clear when-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?

With no annotations, the description carries the full burden and does well: it discloses live web search, xAI Responses API usage, inline citations vs. sources_considered, the x_search toggle, and the default model. It omits rate limits, auth requirements, and cost/latency characteristics, but the core read-only query behavior is clear.

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 compact and front-loaded: purpose and return shape come first, followed by concise behavioral details. No sentence is 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 fully documented. However, with no annotations and 0% schema parameter coverage, the description remains incomplete for a four-parameter tool because system_prompt and model semantics are not explained.

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 0%, so the description must compensate. It explains x_search and the default model, and the purpose implies the question parameter, but it does not explain system_prompt or describe valid model values.

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: ask Grok a question and return an answer with cited URLs. The provider name distinguishes it from sibling LLM query tools such as openai_query, claude_query, and perplexity_query, though it does not explicitly compare itself to 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 implied by the provider-specific name and the live web search capability, but the description does not say when to choose this over perplexity_query, openai_query, or multi_llm_query, nor does it state exclusions.

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 carries full burden. It fully discloses that the tool returns specific data (coverage state, last crawl time, mobile usability, etc.) and notes performance constraints (slow, rate-limited). No destructive behavior is implied.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three concise sentences: purpose, return data, and performance warning. No redundant or extraneous information. Front-loaded with the core action.

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 return values (partially listed, but output schema exists for details) and performance characteristics. It lacks prerequisites (e.g., GSC access) or error handling info, but for a simple inspection tool, it is reasonably complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not add meaning to the three parameters (site_url, url, language_code). It only generically refers to 'a specific URL', leaving the agent to infer parameter roles from the schema alone.

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 ('Get') and clearly identifies the resource ('index status for a specific URL via the URL Inspection API'). It enumerates the return fields, distinguishing it from sibling tools that handle different operations (e.g., gsc_list_sites, gsc_performance).

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 warns about slowness (~1s/call) and rate limiting, providing crucial usage context. It does not explicitly state when not to use the tool or name alternatives, but the warning helps agents decide whether 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?

With no annotations, the description carries the full burden. It mentions 'authenticated user' and the return format, but does not disclose whether the operation is read-only, pagination details, or potential side effects. Lacks explicit safety or behavioral traits beyond the listing itself.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three concise sentences with clear front-loading of purpose, then return details, then usage guidance. No unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple listing tool with no parameters and an existing output schema, the description covers all needed context: purpose, return fields, and how to use the output with sibling tools. Complete and sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters defined in the schema; baseline score of 4 as per guidelines. The description adds value by explaining the output structure, but there are no params to document.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the verb 'List' and the resource 'Search Console properties', and describes the return fields. Explicitly distinguishes from sibling tools by directing use of siteUrl as input to other gsc_* 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?

Provides explicit guidance: 'Use siteUrl from this list as input to other gsc_* tools.' This tells when to use this tool as a prerequisite. No explicit when-not, but the guidance is clear and actionable.

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?

No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, rate limits, data latency, or that the tool queries historical data with default dates. Without annotations, the description should fill this gap but fails to do so.

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 at two words, which is efficient but at the cost of necessary detail. It front-loads the verb but provides no structure or additional context that earns its presence.

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 the existence of an output schema, the description fails to provide sufficient context for a tool with 8 parameters and many sibling tools. It does not mention typical use cases, what the output represents, or how to interpret results, making it incomplete.

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%, with all parameters having adequate descriptions within the schema. The tool description itself adds no additional semantic meaning beyond what the schema already provides, so the baseline 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 'Query GSC search analytics', which specifies a verb and a resource, but it is overly generic and does not differentiate this tool from sibling tools like gsc_inspect_url or snapshot_gsc. It conveys the basic purpose but lacks specificity.

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?

There is no guidance on when to use this tool versus alternatives such as gsc_inspect_url or trend_gsc. The description provides no context about preferred use cases or conditions that would make this tool appropriate.

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 carries the full burden of behavioral disclosure. It mentions submission/resubmission but does not disclose side effects (e.g., overwrites, re-crawl triggering), rate limits, authentication needs, or success/failure behavior. This is a significant gap for a mutation 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 concise with two short sentences. The first sentence clearly states the purpose, and the second provides parameter insight. No redundant content, though it could be more structured with bullet points.

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 2 required parameters, no annotations, and an output schema (not shown). The description is too minimal to cover what the tool does, what is expected, or how to interpret results. More context about the submission process and response is needed.

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 0%. The description explains only feedpath (absolute URL with example) but omits site_url. It adds partial meaning but does not compensate for the missing schema descriptions, leaving one parameter completely unexplained.

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 (submit/resubmit) and the resource (sitemap URL to GSC). It also explains the feedpath parameter. However, it does not explicitly distinguish from sibling tools like bing_submit_url or indexnow_submit_url, but the tool name and context make it specific to GSC.

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 no guidance on when to use this tool versus alternatives, nor does it specify prerequisites or exclusions. It only implies usage for submitting sitemaps to GSC.

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?

No annotations are provided, so the description carries the full burden. It mentions the notification of multiple search engines and the env var requirement, but lacks details on rate limits, error handling, or what happens if prerequisites aren't met. The behavioral disclosure is minimal.

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 two sentences. The first sentence states the purpose, and the second adds a prerequisite. It is front-loaded and wastes no words, though structure could be slightly improved by grouping requirements separately.

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 low complexity (one parameter, no enums) and presence of an output schema, the description still lacks explanation of return values, side effects, or domain restrictions. It leaves the agent with incomplete context for a production environment.

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 0%, and the description adds no meaning beyond the schema for the 'url' parameter. It only says 'a single URL' without specifying format, validation, or other constraints.

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 verb 'Notify' and the resource 'a single URL', listing specific search engines. It distinguishes from the sibling tool 'indexnow_submit_urls' by specifying 'single URL'.

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 prerequisite (env var and hosted key file) but does not explicitly state when to use this tool vs alternatives or when not to use it. Usage is implied but not fully guided.

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?

Without annotations, the description carries full burden. It discloses the batch constraint (shared host) but lacks details on idempotency, error handling, or rate limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences: first defines action and capacity, second provides usage guidance. No redundant words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers purpose, batch limit, and host constraint. Output schema exists, so return values are not required. Could briefly mention protocol to avoid ambiguity, but not necessary.

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 0%, but description compensates by adding the essential constraint that all URLs must share one host, which is not in 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 description clearly states the tool's action ('batch-notify search engines') and scope ('up to 10,000 URLs, must share one host'), distinguishing it from sibling tools like 'indexnow_submit_url'.

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 suggests use cases ('Best for sitemap-wide rebuilds or large content updates'), but does not explicitly exclude single URL submissions or reference alternatives.

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 description explains the tool's behavior well, including return values and special handling of site_host and URL slug matching. However, with no annotations, it does not explicitly declare read-only nature or potential side effects, though implied.

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, well-structured, and front-loaded with the core purpose. Every sentence adds value without 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 the tool has an output schema, the description is complete: it explains input parameters thoroughly and still describes return values for clarity. No gaps remain.

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?

With 0% schema description coverage, the description fully compensates by explaining each parameter's purpose: folder (required), pattern (default *.html), limit (default 1000), and site_host (for absolute URL resolution). Adds significant meaning beyond bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool audits a folder of HTML pages as a directed internal-link graph and lists specific outputs (counts, orphans, dead-ends, top hubs, dangling hrefs), distinguishing it from sibling audit 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 provides clear context on when to use the tool (auditing folder of HTML pages for link graph) and explains optional parameters like site_host, but does not explicitly mention when not to use or name alternative tools.

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 full burden and does substantial work: it discloses that every application/ld+json block is parsed including @graph, which validators are used for which types, the exact per-entity return shape, and the condition that makes ok false. It omits operational behavior such as what happens when the URL is unreachable or the file cannot be read, and whether any network/auth constraints apply.

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 purpose, then the source semantics, then coverage and return contract in a logical order. The long enumeration of supported types is verbose but earns its place by telling the agent which markup will actually be checked.

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, yet the description still summarizes the return fields, which is a bonus rather than a gap. The one remaining hole is guidance on choosing between this and lint_schema_site for site-wide validation.

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 0% and the sole parameter is a bare string, so the description carries the entire burden — and it does, stating that source is a local HTML file or an http(s) URL. That is the exact ambiguity an agent would otherwise have to guess at.

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 specific verb+resource: validate a page's JSON-LD against Google's structured-data requirements, and enumerates the covered entity types, so an agent knows exactly what is checked. It never mentions the sibling lint_schema_site, so the page-vs-site distinction is left to the tool name rather than stated in the description.

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 the phrase 'a page's JSON-LD' and the source parameter accepting a single file/URL; there is no explicit statement of when to pick this over lint_schema_site or audit_page. It does clarify one scoping decision (FAQPage/HowTo fall back to schema.org because Google no longer shows those rich results), which is helpful context but not 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?

With no annotations, the description carries the full burden, and it does disclose the shape of results: errored files, files with no JSON-LD at all, type counts, common missing properties, per-file problems — a meaningful definition of what counts as an issue. However it omits the safety profile (read-only? no writes?), the truncation behavior implied by limit=500, and whether folder traversal is recursive.

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 single-sentence purpose followed by a compact enumeration of outputs; no filler. The return-value list is slightly redundant given an output schema exists, but it is short and each item adds information.

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 needn't be detailed here, and the description is adequate for the core operation. But for a batch tool with a 500-file default limit and a glob pattern, the absence of any note on recursion, limits, or truncation leaves gaps an agent needs 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 description coverage is 0% — none of the three parameters (folder, limit, pattern) are documented in the schema, and the description adds nothing about them. 'Every HTML file in a folder' hints at the pattern default but never explains it, nor what limit controls or what happens when it is exceeded.

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 and scope: it runs lint_schema_page over every HTML file in a folder. This immediately distinguishes it from the sibling single-page linter lint_schema_page without requiring the agent to open 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?

The batch-over-folder framing implies when to use it versus the single-page lint_schema_page, but the description never states the choice explicitly or gives exclusions (e.g. don't use on huge trees, use audit_site instead for broader audits). Usage must be inferred from scope.

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 communicates a safe read operation. It implies no side effects, which is sufficient for this simple list 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 a single, concise sentence that conveys the tool's purpose directly. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no parameters and an output schema, the description is complete. It tells exactly what the tool returns and the condition for inclusion.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are no parameters (0 params), so the baseline is 4. The description does not need to add parameter 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 clearly states the tool returns LLM engines that have an API key, with a specific verb and resource. It effectively distinguishes from siblings like openai_query or gemini_query, which are query 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 provides clear context for when to use the tool (to check configured engines), but doesn't explicitly state alternatives or 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?

With no annotations, the description carries the full load, and it does disclose real behavioral traits: LLM answers vary run to run, each question is sampled `samples` times (default env var, max 10), and cost scales with questions x samples x engines. It does not explain what max_concurrency does or note the read-only/network cost profile beyond the scaling note.

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 headline sentence is front-loaded, the bullet list maps cleanly to output metrics, and the sampling/cost note is a tight closing paragraph. Minor redundancy between 'top_competing_domains and per-question results' and the output schema, but nothing gratuitous.

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 six-parameter, multi-engine batch tool with an output schema present, the description covers the workflow (feed questions, sample counts, cost), the key metric semantics, and brand-alias guidance. The gaps are the undocumented `engines` and `max_concurrency` parameters, which keep it from being fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate. It explains `samples` (default env var, max 10), `brand_aliases` (with an example), and implicitly `questions` and `target_domain`, but leaves `engines` and `max_concurrency` completely undocumented — two of six parameters with no meaning anywhere.

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: it measures how often each configured LLM cites or mentions a target domain, with named metrics (citation_rate, mention_rate) and named engines. It self-identifies as the 'headline GEO/AEO tool', which helps an agent prioritize it, but it never explicitly differentiates itself from citation-checking siblings like aio_citation_check or perplexity_citation_check.

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 tells the agent what to feed it ('your top 20-50 buyer questions') and when to pass brand_aliases ('if your brand isn't obvious from the domain'). No explicit when-not-to-use or named alternative routing, so it stops 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?

No annotations exist, so the description carries the full burden, and it does disclose meaningful behavior: execution is parallel, failures are isolated per engine ('Engines that error are reported per-engine and don't block the others'), and results depend on which credentials are configured. It omits cost/latency implications of fanning out to six providers, which matters for an agent deciding whether to call it.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three tight blocks with zero waste. The core action is front-loaded, the parameter detail follows, and the failure-isolation note is last — exactly the order an agent needs.

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 explained. Given only two parameters, the description covers the non-obvious one exhaustively, explains the default engine set, names where to check credentials, and states partial-failure semantics — 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 0% and the `engines` property is an unconstrained string array, so the description is the only source of the valid values; it supplies the full list ["perplexity","openai","anthropic","gemini","grok","brave"] plus the null/'all configured' default. `question` is left undescribed but is self-evident from the required-string schema and the opening sentence.

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 ('ask the same question to all (or selected) configured LLM engines in parallel'), which inherently separates it from the single-engine siblings like perplexity_query, openai_query, claude_query and gemini_query. It does not, however, distinguish itself from the similarly named sibling multi_llm_citation_check, which an agent could easily confuse with it.

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 concrete operating context: `engines` is an optional subset, the default is every engine with credentials, and the agent is pointed at geoseo_status to discover which engines are configured. There is no explicit 'when not to use this' or a pointer to the single-engine siblings, so it stops short of full 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?

With no annotations, the description carries the full burden. It usefully discloses the underlying API (OpenAI Responses API), the web_search tool usage, the default model environment variable, and the return shape. However, it does not mention API key requirements, rate limits, cost implications, or error behavior.

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 brief, front-loaded with the core purpose, and every sentence adds useful context (return shape, underlying API, default model). There is no redundant or wasted text.

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 explained further. However, with no annotations and 0% schema description coverage, the description should cover the 'system_prompt' parameter and basic operational expectations like API key or rate-limit behavior; those gaps keep it from being complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain all three parameters. It partially covers the 'question' parameter and mentions the default model, but 'system_prompt' is never explained and the 'model' parameter is only partially addressed via the default-model note.

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 action ('Ask ChatGPT'), the resource (a question), and the return shape (answer + cited URLs). The engine name distinguishes it from sibling LLM query tools like claude_query or gemini_query, but it does not explicitly contrast itself with multi_llm_query or list_llm_engines.

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 this is for OpenAI/ChatGPT queries with web search, but gives no explicit guidance on when to use it versus the many sibling chat/LLM query tools. There are no stated exclusions or alternative-routing hints.

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?

No annotations are provided, and the description does not disclose behavioral traits such as side effects, authorization requirements, rate limiting, or whether the tool is read-only. The description is insufficient for the agent to understand operational behavior.

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 sentence, which is concise but lacks essential details. It is not overly verbose, but it sacrifices completeness for brevity.

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 having an output schema, the description does not explain return values or provide enough context for a 3-parameter tool. The description is incomplete for an agent to use the tool effectively without additional lookup.

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 0%, yet the description only mentions 'target_domain' and 'questions' without explaining their format, constraints, or the optional 'model' parameter. The description fails to add meaningful context beyond 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?

Description clearly indicates the tool checks citation share for a target domain across a batch of Perplexity questions. It distinguishes itself from sibling tools like 'aio_citation_check' by specifying Perplexity as the source.

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?

No guidance on when to use this tool versus alternatives like 'snapshot_llm_citations' or 'multi_llm_citation_check'. No preconditions or use cases are mentioned.

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?

No annotations are provided, so the description carries the full burden. It usefully discloses the execution path (Agent API + web search) and the return shape, but says nothing about cost, latency, rate limits, API-key requirements, or whether results are cached — all material for an external paid query.

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 core purpose and return shape, then parameter hints. Two short sentences with no filler; the parenthetical is compact and 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 return values needn't be detailed, and the tool is not deeply complex. Still, with no annotations, 0% schema coverage, and two undocumented parameters, the description leaves an agent guessing about token limits and system-prompt behavior.

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 0%, so the description must compensate and it only partly does: it explains 'model' with a concrete example and the 'fast' effort preset default. Neither 'max_tokens' nor 'system_prompt' is mentioned at all, leaving half the parameters undocumented everywhere.

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 ('Ask Perplexity'), names the mechanism (Agent API + web search), and states the return shape (answer + cited URLs/domains). It does not distinguish itself from the many sibling LLM-query tools (openai_query, grok_query, claude_query, multi_llm_query) — it relies on the name alone to convey that choice.

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 only conditional guidance is internal to parameters ('defaults to fast effort preset', 'pass model to pin one'). There is no when-to-use, when-not-to-use, or sibling routing advice, which is a real gap given ~8 competing query tools in the sibling list.

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 full burden. It states persistence but does not disclose side effects (overwrite vs. append), idempotency, or permission requirements. The only behavioral detail is default dimensions.

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 two sentences with no fluff. The first sentence states purpose and the second provides usage guidance. Every word 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 6 parameters, no schema descriptions, and no annotations, the description is incomplete. It lacks parameter semantics and behavioral details. The output schema exists but is not referenced, so the description does not compensate.

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 0% and the description only mentions default dimensions for one parameter. It provides no explanation for site_url, start_date, end_date, row_limit, or search_type, leaving 5 of 6 parameters undocumented.

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 verb 'Run' and the resource 'GSC performance query' with the outcome 'persist the rows as a snapshot'. It distinguishes from sibling gsc_performance by emphasizing persistence and scheduling for time-series.

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 to run on a schedule (cron, n8n, lauchd) to build a time-series, providing clear use context. However, it does not mention when not to use or explicitly compare to alternatives like gsc_performance.

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 must carry the full burden, and it does disclose the write side effect (results are persisted) plus the majority-vote aggregation rule when samples > 1. It omits whether an existing snapshot is overwritten, run cost/latency of multiple engines x samples, and auth requirements for the persistence layer.

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 action and three compact sentences with zero filler. Minor noise from doubled-backtick RST markers that render as formatting artifacts rather than adding meaning.

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 explained, and persistence plus sampling semantics are covered. Still missing for a 4-param, 0%-schema-coverage write tool: what questions/target_domain expect and the cost implications of fanning out across all engines.

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 0%, so the description carries real weight and it partially does: it explains engines defaulting to all configured LLMs (pointing at geoseo_status) and defines samples as a majority threshold, not just a repeat count. Questions array shape and target_domain meaning are left entirely to the bare 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?

A specific verb plus resource: 'Run multi-LLM citation check and persist the per-question results.' It separates itself from the non-persisting sibling multi_llm_citation_check and names the downstream consumer trend_llm_citations, so the snapshot-vs-check distinction is legible without reading schemas.

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 implies usage by naming the dataset it feeds ('Builds the dataset behind trend_llm_citations'), which tells the agent this is the sampling step before trending. But there is no explicit when-to-use vs multi_llm_citation_check or perplexity/aio_citation_check, and no prerequisites or exclusions.

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?

No annotations provided, so the description must convey side effects and constraints. 'Persist' implies state change, but there is no mention of idempotency, permissions, rate limits, or cost (SerpAPI is external). The description does not warn about potential destructive or resource-heavy behavior.

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 sentence with no fluff. It efficiently conveys the core action and data flow.

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 basic operation and output storage, but lacks guidance on input semantics and behavioral expectations. Given the existence of an output schema, return values need not be detailed, but the overall context for tool selection is thin.

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 0%, yet the description does not explain what the 'queries' and 'target_domain' parameters mean. The agent must infer that queries are search terms and target_domain is the scope, which is insufficient for correct invocation.

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: run an AIO citation check via SerpAPI and persist results. It distinguishes from siblings like aio_check and aio_citation_check by emphasizing persistence. However, the term AIO is not defined, and 'engine rows' is jargon that may confuse an agent.

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?

No guidance on when to use this tool versus siblings. Sibling tools include multiple citation check and snapshot tools, but the description provides no context about when to choose this one, e.g., for which scenarios or data needs.

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 full behavioral burden and does well: it discloses the default algorithm, the embedding alternatives, SQLite caching by content hash so re-runs are cheap, and that already-existing links plus self-links are excluded. It omits prerequisites such as API key requirements or cost for the openai/gemini modes.

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 core action and scope are front-loaded in the first line, followed by mode behavior and output detail in a logical order. A few clauses, such as the anchor_hint sentence, are useful but push toward the verbose side.

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 an 8-parameter tool, the description covers the essential call path (folder, mode, page scope, top-K) and return semantics are handled by the existing output schema. The gaps are the secondary parameters limit, pattern, and site_host, which an agent cannot infer at all.

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 0%, so the description must compensate, and it only partially does. It explains mode, model, folder scoping, top_k, and the page filter, but leaves limit, pattern, and site_host entirely undefined in both schema and prose.

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 (suggest) and resource (internal links) with explicit scope: top-K links to add per page in a folder. This is clearly distinguishable from graph-oriented siblings like internal_link_graph, since it produces actionable suggestions rather than an analysis of existing links.

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 explains the default approach and lists the alternative mode values with their models, which implies when to switch to embeddings. But it never says when to prefer this tool over internal_link_graph, nor are there exclusions or cost trade-off guidance beyond 'offline, free' for the default.

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?

No annotations provided, so description carries full burden. It mentions aggregation by captured_at, filtering, chronological ordering, and limit. However, it does not explicitly state read-only behavior, data freshness, or that it queries stored snapshots (though that's implied). Additional behavioral context like safety or rate limits would be beneficial.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, each serving a purpose: first defines the tool's output, second explains aggregation and filtering. No redundant wording. Optimal length for the information provided.

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 core functionality: time-series from stored GSC snapshots, filtering, and ordering. With an existing output schema, it is reasonably complete. However, missing details like data source freshness or parameter format slightly reduce completeness.

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 0%, so description must compensate. It adds meaning to site_url (required), query and page (optional filters), and limit (default 50). However, it lacks details on valid formats or constraints for parameters, especially query and page. The description provides minimal extra value beyond the schema structure.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool returns time-series data (clicks/impressions/position) from stored GSC snapshots, aggregated by captured_at. It distinguishes itself from siblings like gsc_performance and snapshot_gsc by specifying the source and aggregation.

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 explains filtering by query and page for drill-down, and the limit parameter. It implies usage for trend analysis but doesn't explicitly state when not to use or mention alternatives. Sibling context provides additional 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?

No annotations are provided, so the description carries the full burden. It discloses the conditional creation and returned path, which is adequate for a simple tool. However, it omits details like error handling, file locking, or whether existing DBs are overwritten (implied not, but not explicit). With no annotations, more transparency would be beneficial.

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 concise sentence that front-loads the action and outcome. It contains no superfluous information. While it could be slightly more structured (e.g., listing side effects), it is 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?

Given zero parameters and the existence of an output schema (implied), the description provides the essential purpose and return. It does not explain relation to siblings or prerequisites, but for a simple init tool, it is sufficiently complete. The context signals confirm no parameters and an output schema, so the description does not need to detail return values.

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 coverage is 100% trivially. The description adds no parameter-level detail, but none is needed. Baseline for 0 params is 4, and the description is adequate.

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 creates a local SQLite snapshot DB conditionally and returns its path. The verb 'create' and resource 'local SQLite snapshot DB' are specific, and the condition 'if it doesn't exist' adds clarity. However, it does not explicitly differentiate from sibling snapshot_* tools, which may have overlapping functionality.

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 no guidance on when to use this tool versus alternatives. Given multiple sibling tools like snapshot_gsc and trend_gsc, an explicit context or prerequisite relationship would help. The tool likely serves as initialization, but this is not 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 must disclose behavioral traits. It does not mention whether the tool is read-only, requires authentication, has rate limits, or any side effects. It only describes the output format, leaving the agent uninformed about important 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: two sentences that front-load the purpose and output, then clarify the engine parameter. Every word adds value, with no fluff 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?

While an output schema exists and the description lists output columns, it lacks context on what a snapshot is, how timestamps are handled, and the limit parameter's effect. For a time-series tool, additional detail would improve completeness, but the basic functionality is conveyed.

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 0%, so the description must compensate. It explains that engine filters to one of five specific values and that target_domain is a domain string. However, limit parameter is not mentioned, and the description does not fully cover all 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 clearly identifies the tool's purpose: returning per-snapshot citation share for a target domain over time. It specifies the output columns and the optional engine filter, making the intent unambiguous. However, it does not explicitly differentiate from siblings like snapshot_llm_citations or multi_llm_citation_check.

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 no guidance on when to use this tool versus alternatives (e.g., snapshot_llm_citations for a single snapshot, list_llm_engines for available engines). No prerequisites, when-not-to-use, or context for choosing this trend tool.

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 full burden, but only lists output types. It does not disclose read-only behavior, rate limits, or data freshness. The minimal behavioral insight limits transparency.

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?

Single sentence, no superfluous words. Front-loaded with the core action 'Inventory of what's stored'. Efficient and to the point.

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 parameterless tool with an output schema, the description adequately summarizes the content. It could benefit from mentioning the output format (list/object) but the existing output schema likely covers that.

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?

Since there are zero parameters and schema coverage is 100%, the description adds context about the output (row counts, sites/domains, snapshots), which goes beyond the empty schema. Baseline 4 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 returns an inventory of stored data including row counts, sites/domains, and snapshot ages. It uses a specific verb and resource, but does not explicitly differentiate from sibling tools like trend_gsc or trend_init.

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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention use cases, prerequisites, or exclusions.

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?

Without annotations, the description carries the burden of behavioral disclosure. It explains that it returns a parsed structure and an issues list with line numbers, and lists some violation types (missing H1, broken links, non-HTTP URLs). However, it does not mention side effects, auth needs, or rate limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences long, front-loaded with the main purpose, and the second sentence adds valuable detail on output. No unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has a single parameter, an output schema (present), and low complexity, the description is sufficiently complete. It covers what the tool does and the output structure without needing to repeat schema details.

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 has 0% description coverage. The description adds meaning by specifying that 'source' can be a local path or URL, but it does not detail format requirements or expected schemes. This is helpful but minimal for a single 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?

The description clearly states the tool validates an llms.txt file against a spec, with a specific verb ('validate') and resource. It distinguishes from sibling tools like generate_llms_txt and other audit 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 does not provide any guidance on when to use this tool versus alternatives, nor does it mention prerequisites, exclusions, or context. It only states what the tool does.

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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only diagnostic but never confirms non-destructiveness, says nothing about required account/permission scope, rate limits, or whether results are cached — all relevant for an external API call.

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 compact sentence, front-loaded with the primary capability and appending the secondary output. Every clause carries information, though the parenthetical '(by severity)' is slightly awkward phrasing.

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, and the single-parameter surface is small. However, the format of 'site' and what 'diagnostics' actually enumerates remain unstated, leaving a workable but incomplete definition.

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 single required 'site' parameter has 0% schema description coverage, and the description does not state whether it expects a full URL, a hostname, or a Yandex site ID. With low coverage the description is expected to compensate, and it does not.

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 resource (Yandex site diagnostics) and a specific output (severity-based issues plus sample broken internal links), which distinguishes it from the sibling bing_crawl_issues by engine and from link-only tools like find_broken_external_links. The verb is implicit ('diagnostics') rather than an explicit action, which keeps it from a 5.

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?

There is no statement of when to use this versus bing_crawl_issues, audit_site, or internal_link_graph, and no prerequisites such as site verification or Yandex Webmaster access. The agent must infer usage entirely from the tool name and sibling list.

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 full burden and does disclose that results are scoped to the token owner's account, which tells the agent no account/credential parameter is needed. It says nothing about pagination, result limits, or whether an empty list is possible for an unverified account — gaps that matter for a listing call.

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 sentence, front-loaded with the verb and resource, zero filler. Nothing could be removed without losing meaning.

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 read tool with an output schema that documents return values, the description covers the essentials: what is listed and whose account it comes from. Adding the typical follow-up tools would make it complete, but nothing required to call 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?

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to clarify. The mention of token-owner scoping is a useful implicit confirmation that no site filter is accepted.

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 ("List sites") and scopes it to "the token owner's Yandex Webmaster account," which cleanly separates it from the gsc_list_sites and bing_list_sites siblings by platform. It stops short of saying what a 'site' object contains or how results differ from yandex_site_summary, but the core action is 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?

Usage is only implied: an agent can infer this is the discovery step before yandex_site_summary, yandex_query_stats, or yandex_submit_url, but the description never says so or names an alternative. No preconditions or exclusions are given.

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?

No annotations are provided, so the description carries the burden; it does disclose the returned metrics, the date format, and the default window (last week), which is useful behavioral context. It omits that this is a read-only stats call, says nothing about the 500-row default limit's effect, rate limits, or truncation behavior.

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 in one sentence, then parameter notes in a compact second block. Slightly marred by doubled-backtick formatting noise, but there is 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 described. Still, for a 6-parameter tool with 0% schema coverage, missing guidance on 'limit' (pagination/capping behavior) and on which Yandex data source this queries leaves gaps an agent must guess at.

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 0% and the schema declares no enums, so the description is doing real work by enumerating the valid order_by values (TOTAL_SHOWS/TOTAL_CLICKS) and the five device values, plus the YYYY-MM-DD date format and last-week default. It leaves 'site' and 'limit' unexplained, which keeps it below a 5.

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 and metric set: top Yandex search queries with shows, clicks and average position. An agent can distinguish it from aggregate siblings like yandex_site_summary, though the description never explicitly contrasts the two.

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 implied by the resource name (query-level performance reporting for a site), and the order_by/device values hint at the reporting use cases. There are no explicit when-to-use or when-not-to-use statements, and no routing away from yandex_site_summary or bing_query_stats.

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?

No annotations are provided, so the description carries the full behavioral burden. It lists output metrics but does not explicitly state that the operation is read-only, whether authentication is required, or whether there are rate limits. The read-only nature is strongly implied but not disclosed.

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 short and front-loaded with the key metrics returned, followed immediately by the parameter format. There is no filler; every sentence adds useful information.

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 an output schema exists and the tool has only one documented parameter, the description is largely sufficient for correct invocation. The main gap is the absence of usage context versus sibling tools, but that is addressed in the usage dimension.

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?

With 0% schema description coverage, the description compensates well by explaining that the single required site parameter accepts either a URL (https://example.com/) or a Yandex host id (https:example.com:443), including concrete examples.

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 identifies the resource and the metrics returned: SQI, pages in search, excluded pages, and problem counts for a Yandex site. It is a specific summary capability, but it does not explicitly differentiate itself from siblings like yandex_url_info or yandex_crawl_issues.

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 states what the tool returns and how to format the site parameter, but gives no guidance on when to use it instead of alternatives such as yandex_url_info, yandex_list_sites, or yandex_crawl_issues. It also provides no prerequisites or exclusions.

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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that submission is queued (asynchronous, not immediate) and that a daily quota applies, but omits whether the site must be verified, whether the URL must belong to the site, what happens when the quota is exhausted, and whether failures are reported.

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 short sentences with the core action front-loaded and the key constraint second. No filler. Slightly terse given the missing behavioral and parameter detail, but nothing is wasted.

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 mutation tool with no annotations and zero schema descriptions, the description is too thin. An output schema exists, so return values needn't be explained, but the description should cover verification requirements, quota behavior, and parameter expectations to make the tool safely callable.

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 0%, so neither 'site' nor 'url' is documented anywhere. The description does not explain the expected format of 'site' (host vs. full URL), the required relationship between 'site' and 'url', or whether the URL must be on that site. The parameter names are suggestive but the description compensates for none of the coverage gap.

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: 'Queue a URL for Yandex recrawl.' This distinguishes it as a submission tool rather than a read tool. However, it does not differentiate from siblings like indexnow_submit_url, bing_submit_url, or gsc_inspect_url, leaving an agent to infer that this is the Yandex-specific channel.

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?

Implied usage is clear from 'Queue a URL for Yandex recrawl,' and the quota constraint is disclosed. But there is no guidance on when to prefer this over indexnow_submit_url or bing_submit_url, no prerequisites (e.g., site verification), and no when-not-to-use statement.

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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only status lookup but does not disclose auth requirements, rate limits, side effects, or whether site must match the URL; behavioral transparency is minimal.

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 definition is a single efficient sentence with no filler or repetition. It is front-loaded with the core information type, though the phrase 'Monitoring important pages' is somewhat ambiguous.

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 do not need explanation. However, with no annotations and no schema parameter descriptions, the definition should clarify the two required inputs and when to use this tool instead of siblings; it leaves those gaps 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?

There are two required parameters with 0% schema description coverage. The description generically mentions 'a URL' but never explains the required 'site' parameter or the expected relationship between site and URL, so it adds only minimal meaning beyond the schema property names.

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 resource (URL), provider (Yandex), and information type (indexing + search status), so an agent can tell it is a URL-status lookup. It does not differentiate this tool from siblings such as yandex_site_summary or bing_url_info, keeping it below a 5.

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?

There is no explicit when-to-use or when-not-to-use guidance. The description does not name alternatives like yandex_site_summary for site-level summaries or yandex_submit_url for indexing submissions, leaving usage entirely inferred.

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