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

No annotations are provided, so the description carries the full burden of behavioral disclosure. For a mutation tool it only offers a minimal Raises clause (BingWebmasterError on failure) and omits what happens on success, reversibility, or permission requirements. With zero annotation coverage this is a significant gap.

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 docstring format front-loads a one-line purpose followed by an informative Args list and a compact Raises note. It is well-structured with no filler; the only low-value element is the minimal Raises clause, but it does not bloat the description.

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

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

An output schema exists, so return-value explanation is not required. Parameters are thoroughly covered, but the description omits usage context and behavioral detail that a write operation with no annotations should supply, leaving the agent without guidance on when to call 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 description coverage is 0%, and the description fully compensates by documenting all 5 parameters, including the enum semantics (Page or Directory for entity_type, CacheOnly or FullRemoval for request_type) and the date default (minimum datetime). This adds meaning the schema itself does not provide.

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?

"Add a blocked URL to a site" states a specific verb and resource, and the parameter list clarifies the domain (Bing Webmaster URL blocking). It is distinguishable from sibling tools remove_blocked_url and get_blocked_urls by its operation, 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?

There is no when-to-use or when-not-to-use guidance, no prerequisites, and no mention of alternatives. The description is purely declarative and leaves the agent to infer when blocking a URL is appropriate versus using remove_blocked_url.

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 that the operation adds a page and raises BingWebmasterError on failure, but doesn't mention whether the operation is idempotent, whether it requires prior site verification, or what happens if the page is already connected. The error mention is useful but 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 compact and front-loaded with the core purpose. The Args and Raises sections are standard and efficient. No wasted words, though the Raises section is somewhat generic.

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 no output schema details, the description is thin. It doesn't explain return values, idempotency, prerequisites, or failure modes beyond a generic exception. An agent would need to infer a lot about how to call this 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%, so the description must compensate. It lists both parameters with brief definitions ('The URL of your site', 'The URL of the page to be connected'), which adds some meaning beyond the bare schema. However, it doesn't clarify URL formats, whether master_url must be on the same domain, or any 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 states a specific verb and resource: 'Add a page which has a link to your website.' This clearly identifies the action and target. It doesn't explicitly distinguish from siblings like add_deep_link_block or add_page_preview_block, but the resource (connected page) is distinct enough.

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. It doesn't mention prerequisites like verifying the site first, or contrast with get_connected_pages or other add tools. The context is implied by the name and description but not explicit.

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 discloses that it raises BingWebmasterError on failure (useful), but does not mention potential side effects, idempotency, whether it overwrites existing settings, or required permissions. As an add operation, the mutating nature is inferred but not explicitly stated, and no response format is described despite having an output schema.

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

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

The description is compact: a one-line purpose and a short Args section. Each sentence earns its place; no fluff. However, it could be improved by adding brief value mentions of key fields, but it's not verbose.

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 moderate complexity (nested settings object, required fields, enum), the description is under-specified. No example, no return value explanation (though output schema exists, the description doesn't confirm what to expect), no error handling details beyond naming the error type. For a mutating operation with no annotations, more context is needed 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?

Schema description coverage is 0%, and the description only repeats parameter names: 'site_url: The URL of the site' and 'settings: The country/region settings to add'. This adds no meaning beyond the schema's parameter titles. The nested CountryRegionSettings object is not explained; the agent must infer its required fields from the schema, which does provide them, but the description doesn't help interpret the enum values of 'Type' or the meaning of 'TwoLetterIsoCountryCode'.

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 ('Add') and resource ('country/region settings') for a specific site. Distinguishes from siblings like get_country_region_settings and remove_country_region_settings by naming the operation explicitly, though it doesn't name 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?

No guidance on when to use this tool versus alternatives. It doesn't mention that get_country_region_settings is for retrieval or remove_country_region_settings for deletion, nor does it specify prerequisites like verifying site ownership first. The description implies usage via 'Add' but doesn't provide 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?

No annotations are provided, so the description carries the full burden. It only mentions that a BingWebmasterError may be raised, which is minor. It does not disclose side effects, idempotency, permissions, or what happens on success. For a mutation tool with zero annotation coverage, this is a significant gap.

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 avoids fluff, but it is under-specified. The docstring-style structure with Args and Raises is reasonable, but it lacks front-loaded context or any explanation of the tool's purpose beyond the first line. It is not conciseness that aids the agent; it is just too sparse.

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 four required parameters, no annotations, no parameter descriptions, and no explanation of the return value or behavior, the description is highly incomplete. An agent cannot correctly construct a call without guessing at the meaning of the parameters. The presence of an output schema is not mentioned, and no indication of what the response contains is given.

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 lists four string parameters with no descriptions, and the description merely repeats their names without adding meaning. With schema description coverage at 0%, the description should compensate but does not explain the purpose, format, or constraints of site_url, market, search_url, or deep_link_url.

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 says 'Add a deep link block,' which is a clear verb+resource, but it does not explain what a deep link block is or what the action entails. It does not differentiate from siblings like add_page_preview_block or remove_deep_link_block. It is not a tautology, but it is too vague to guide an agent that lacks domain-specific knowledge.

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. No mention of prerequisites, scenarios, or exclusions. The agent is left to infer that this tool is for adding deep link blocks, but there is no comparison to remove_deep_link_block or other add 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?

Annotations are absent, so the description carries the full burden. It only mentions raising BingWebmasterError on failure, but doesn't disclose side effects, idempotency, reversibility, or what happens if the block already exists. For a mutation tool, this is insufficient behavioral disclosure.

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 with an Args/Raises format. It is easy to parse and front-loads the action. However, the brevity contributes to missing details in other dimensions; conciseness itself is good.

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 3 parameters with an enum, no annotations, and a minimal description. It lacks usage context, enum semantics, return value details, and any mention of prerequisites like site verification. Given the complexity of the Bing Webmaster domain, this description is 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?

The description provides one-line meanings for each parameter: site_url, url, and reason. However, it doesn't explain the enum values for reason (1-4) as defined in the schema. Since schema description coverage is 0%, the description partially compensates but leaves the enum semantics ambiguous.

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 'Add a page preview block' with a clear verb and resource. It lists the three parameters with brief meanings, making the action specific. However, it doesn't explicitly differentiate from sibling tools like add_blocked_url or add_deep_link_block, and could clarify what a page preview block actually does in the Bing Webmaster context.

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 such as add_blocked_url or add_deep_link_block. The description simply states the action without context, exclusions, or mention of scenarios where this tool is preferred. An agent would need to infer based on tool names alone.

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 responsibility for behavioral disclosure. It states that a BingWebmasterError is raised if the parameter cannot be added, which is useful, but it does not disclose side effects, idempotency, authorization needs, or how the normalization parameter is applied.

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

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

The opening sentence is a concise, front-loaded description. The Args and Raises sections add useful information without marketing fluff. The format is slightly verbose due to headings and blank lines, but it remains short and scannable.

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?

This is a mutating tool with no annotations and no output schema, yet the description does not explain prerequisites, effects on existing normalization rules, idempotency, or what happens when the parameter already exists. It only names the inputs and a generic failure condition, so an agent lacks enough context to predict the tool's 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?

The Args section largely restates the parameter names: 'site_url: The URL of the site' and 'query_parameter: The query parameter to add.' It adds almost no meaning beyond the input schema, which already requires those values and constrains query_parameter with a regex pattern. There is no example, no format clarification, and no relation to URL normalization behavior.

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

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

The description opens with a clear verb and object: 'Add a URL normalization parameter for a site.' This states exactly what the tool does and is specific enough to distinguish it from obvious siblings like remove_query_parameter or get_query_parameters. It does not explicitly contrast with other parameter-related tools such as enable_disable_query_parameter, so it stops short of full sibling differentiation.

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 given about when to use this tool versus alternatives like enable_disable_query_parameter or remove_query_parameter. The description provides no context about prerequisites, such as whether the site must already exist or be verified, and does not mention any 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, the description carries the full burden. It discloses that a BingWebmasterError is raised if the site cannot be added, but it does not describe side effects, duplicate behavior, verification requirements, authentication needs, or whether the site is immediately usable.

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 with the main action. The Args and Raises sections are clear, though the Args line is somewhat redundant with the schema. Overall, it is concise without 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?

The tool is simple with one required parameter and an output schema, so the core usage is conveyed. However, important context is missing, such as whether verification is needed after adding a site and what happens if the site already exists. The error clause helps but does not fully compensate for the absent behavioral and usage 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?

Schema description coverage is 0%, so the description must compensate. It only repeats 'The URL of the site to add,' which adds little beyond the schema's 'Site Url' title. It lacks URL format guidance, examples, or constraints such as protocol requirements or trailing-slash normalization.

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 and resource: 'Add a new site to Bing Webmaster Tools.' It clearly identifies the tool's function and distinguishes it from remove_site and verify_site, though it does not explicitly name those 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?

No guidance is given on when to use this tool versus alternatives like verify_site or remove_site. There is no mention of prerequisites, ordering, or exclusions, so the agent must infer usage solely from the verb 'Add.'

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 side effects. It only mentions that a BingWebmasterError is raised on failure knthu and that it delegates access. It fails to explain whether existing roles are overwritten, whether both admin and read-only can be true, or what happens on partial failure.

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 docstring is compact, front-loads the purpose, and separates parameter definitions from a Raises section. It earns a solid score for brevity and readability.

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 action, all six parameters, and the error type. However, it omits context about the semantics of delegating (e.g., whether roles are additive, how the delegated_url relates to site_url, and whether both boolean flags can be true). An output schema exists, so return values need not be described.

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 Arg list gives a one-line gloss for each parameter (e.g., 'user_email: The email of the user to delegate access to'), but these largely restate the parameter names and don't clarify ambiguous fields like delegated_url or the relationship between is_administrator and is_read_only. Schema descriptions are absent, so the description partially compensates but remains shallow.

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

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

The opening line, 'Delegate site access to a user,' clearly identifies the action and target. It is specific enough to convey the tool's primary function, though it does not distinguish it from related tools like remove_site_roles.

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 sibling tools (e.g., get_site_roles, remove_site_roles). The description does not explain prerequisites, typical scenarios, or how roles interact.

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 indicates a mutating operation ('enable or disable') and mentions a Raises clause for BingWebmasterError on failure. However, it does not disclose side effects, reversibility, idempotency, permissions, or prerequisites. For a mutation tool with zero annotation coverage, this is a significant gap.

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. It opens with a single, front-loaded purpose sentence, then lists the arguments with clear definitions, and ends with a raises clause. There is no redundant or verbose text; every sentence earns its place.

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

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

For a simple tool with three primitive parameters and an output schema, the description covers the core action, arguments, and error condition. However, it lacks usage context (when to prefer this over siblings), does not explain the concept of 'URL normalization parameter', and omits any prerequisites like site verification. This is adequate but not complete given the wide range of sibling tools.

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

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

Schema description coverage is 0%, so the description must compensate. It defines each argument: site_url as 'The URL of the site', query_parameter as 'The query parameter to enable/disable', and is_enabled as 'True to enable, False to disable'. This adds meaning beyond the bare schema types and titles, though it could include format hints or domain-specific explanations (e.g., what qualifies as a query 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 action: 'Enable or disable a URL normalization parameter for a site.' This specifies the verb (enable/disable), the resource (URL normalization parameter), and the scope (for a site). It distinguishes itself from sibling tools like add_query_parameter, remove_query_parameter, and get_query_parameters by focusing on toggling state rather than creation, removal, or retrieval.

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. It does not mention that this should be used for existing parameters or that add/remove are for adding/removing. There are no exclusions or explicit context for selecting this over siblings like get_query_parameters or add_query_parameter.

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 that it fetches a URL and raises an error if it cannot be fetched. It does not disclose side effects (e.g., triggering a crawl), authentication requirements, rate limits, or whether it's a write operation. This is minimal disclosure for an action 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 and well-structured with clear sections for purpose, arguments, and exceptions. It avoids fluff and front-loads the action. However, it is extremely terse and omits useful context, which affects other dimensions, but for pure conciseness it is appropriately sized.

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 annotations and minimal description, the information is incomplete for safe and correct use. It lacks details about prerequisites (e.g., site must be verified), potential side effects, return behavior (though output schema exists, it's not referenced), and how it differs from submit_url. An agent would not know when to invoke this tool with confidence.

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 lists 'site_url: The URL of the site' and 'url: The URL to fetch', which adds a basic distinction but does not clarify the relationship (e.g., site_url is the verified site root, url is the specific page). No format, constraints, or examples are given.

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 clear action: 'Request Bing to fetch a specific URL immediately.' It identifies the resource (URL) and the operation (fetch). It doesn't differentiate from sibling tools like submit_url or get_fetched_urls, but the purpose is unambiguous on its own.

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. It doesn't mention conditions, exclusions, or refer to any sibling tool. The agent is left to infer that it's for immediate fetching, but no explicit context is 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?

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly reports the return type (List[PagePreview]) and error behavior (Raises BingWebmasterError). It also indicates read-only behavior by describing a 'get' operation. This is adequate transparency for a simple getter, though it omits details like authentication 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 follows a clear structured format with Args, Returns, and Raises sections. It is concise and the opening sentence front-loads the main purpose. Minimal redundancy, though the parameter explanation is slightly thin.

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

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

For a simple one-parameter getter with an output schema present, the description is largely complete. It covers the action, parameter, return type, and error condition. It could benefit from a brief note on what 'active' means or a dependency on site verification, but overall it provides sufficient context for an agent 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%, so the description must compensate for parameter documentation. However, it only restates the parameter name and adds a generic phrase 'The URL of the site,' which barely adds value over the schema (which already states the property is a required string). No format, validation, or examples are provided, leaving the parameter semantics essentially 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 action ('Get'), the resource ('active page preview blocks'), and the scope ('for a site'). It distinguishes from sibling tools like add_page_preview_block and remove_page_preview_block by emphasizing retrieval of active blocks, making the tool's purpose unambiguous.

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

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

The description does not explicitly state when to use this tool versus alternatives like get_deep_link_blocks. While the name and summary imply it is for retrieving active page preview blocks, there is no guidance on exclusions or when not to use it. The usage context is implied rather than spelled out.

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 return type and the error condition, but does not explicitly state that the operation is read-only or mention any side effects, permissions, or rate limits. The term 'Get' implies read-only, but it is not explicit.

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 well-structured, using sections for Args, Returns, and Raises. The main purpose is stated first, and there is 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 an output schema present, the return structure is defined. The description covers the essential information: what it does, what it returns, and what error it raises. It is adequate for a simple getter with a single parameter.

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 the parameter. It provides a brief but sufficient explanation: 'site_url: The URL of the site'. This adds meaning beyond the schema's bare property name.

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 the action (get), resource (blocked pages/directories), and scope (for a site). It clearly distinguishes from sibling tools like add_blocked_url and remove_blocked_url by being the retrieval operation.

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 no guidance on when to use this tool over alternatives. It does not mention that this is the read-only counterpart to add/remove operations, nor does it specify any conditions for use.

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

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

With no annotations provided, the description must carry the full burden. It discloses the return type and error, but omits pagination behavior, rate limits, auth, or what constitutes a child URL. The behavioral profile is thin for a read operation.

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

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

The description is well-structured with Args, Returns, and Raises sections, and the purpose is front-loaded. It is concise without excessive fluff, though the Args section somewhat duplicates schema field names.

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 existence of a nested filter object and pagination, the description is under-specified. It does not explain page size, default behavior, or the semantics of child URL retrieval. Without annotations, this leaves an agent under-informed for correct invocation.

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

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

The description adds brief explanations for all four parameters, compensating for 0% schema description coverage. However, filter_properties is only described as 'Properties to filter the results' without detailing the enum options, offering limited added value 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 states a specific verb 'retrieve' and resource 'child URLs of a specific URL', clearly distinguishing it from siblings like get_url_info and get_children_url_traffic_info. The resource and action are 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?

No guidance on when to use this tool versus alternatives. It does not mention conditions, exclusions, or point to sibling tools. The usage context is only implied by the name and parameter list, leaving the agent to infer.

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 that it returns a list and raises an error, but does not state whether the operation is read-only, how pagination works, or any rate limits or permissions. This is insufficient for a tool with no annotation coverage.

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 well-structured docstring with Args, Returns, and Raises sections. It is concise and front-loaded with the main purpose. Each section is efficient, though the parameter descriptions could be more detailed without adding excessive length.

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 moderate complexity and the presence of an output schema (though not detailed), the description covers the essential elements: purpose, parameters, return type, and error. However, it lacks usage guidance and behavioral details like pagination semantics or idempotency, making it only partially complete for an agent to call 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%, so the description must explain parameters. It does list each parameter with a brief meaning: site_url, url, and page. However, the explanations are minimal ('The URL of the site') and do not specify format, required status, or constraints beyond the schema. It partially compensates but not fully.

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 'Get' and the resource 'traffic details for child URLs of a directory'. It is specific enough to understand the tool's function, but it does not explicitly differentiate from siblings like get_url_traffic_info or get_children_url_info, which could cause confusion about when to use each.

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. It does not mention prerequisites, context, or when to prefer this over get_url_traffic_info or get_children_url_info. This leaves the agent without explicit selection criteria.

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 does disclose a return type (List[ConnectedSite]) and the error condition (BingWebmasterError), and the verb 'Get' implies a read operation. However, it does not state whether the operation is read-only, whether site ownership/verification is required, or what 'connected pages' means in this context.

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

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

The description is concise and uses a clear Args/Returns/Raises structure. It leads with the primary purpose and adds the error condition, but the Args section is slightly redundant with the schema.

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 input, return type, and error behavior, which is decent for a single-parameter getter. However, it never explains what 'connected sites/pages' means, whether the site must be verified/authorized, or how this differs from related lookup tools like get_sites or get_fetched_urls.

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 parameter has no description (coverage 0%), and the description merely repeats 'The URL of the site,' which is little more than the parameter name. It adds no detail about expected URL format, verification requirements, or how the site_url relates to the connected pages returned.

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 clear verb+resource construction: 'Get a list of pages connected to the site.' This is distinct from sibling tools like get_sites, get_page_stats, and get_fetched_urls. The only minor ambiguity is that Returns is typed as List[ConnectedSite] while the description talks about 'pages,' which could confuse an agent about the exact return shape.

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 given on when to use this tool versus alternatives such as get_page_stats, get_fetched_urls, or get_site_roles. There are no prerequisites, conditions, or distinctions from siblings, leaving the agent to infer appropriate usage from the name alone.

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 repeats the action ('Get information') without stating that it is read-only, idempotent, or requires specific authentication/permissions. It does not mention any side effects or rate limits, which is a gap for a getter.

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 a clear purpose statement and well-organized Args, Returns, and Raises sections. Every line is functional and there is no filler, earning high marks for structure and economy.

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

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

The tool has a single parameter and an output schema that presumably defines ContentSubmissionQuota, so return structure is covered. However, the description does not clarify the relationship to get_url_submission_quota or the exact meaning of 'content submission', leaving a potential ambiguity for an agent selecting among similar quota tools.

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

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

Schema coverage is 0%, so the description must add meaning to the site_url parameter. It provides only 'The URL of the site' – a generic phrase that doesn't clarify format (e.g., full URL vs. domain), required scheme, or whether the site must already be verified. The description does not compensate for the schema's lack of detail.

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 clear verb ('Get') and a specific resource ('content submission quota and usage'). It distinguishes from the sibling get_url_submission_quota by naming the resource type, but it doesn't explicitly contrast the two, so an agent might wonder how they differ.

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

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

The description gives no guidance on when to use this tool versus the very similar get_url_submission_quota. There is no mention of typical invocation context, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.

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 behavioral burden. It does add a failure mode (BingWebmasterError) and implies a read-only operation via 'Retrieve', but it does not mention permissions, side-effect freeness, rate limits, or other behavioral details.

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?

Compact docstring with a front-loaded one-line summary followed by Args, Returns, and Raises. No filler or redundant background 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 single-parameter getter with an output schema, the description covers what is retrieved, how to specify the site, and a failure mode. It does not discuss the relationship to add/remove country/region settings, but that is not essential for invoking this tool correctly.

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

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

The input schema only provides a title ('Site Url') with no schema description. The description compensates by stating 'site_url: The URL of the site to get settings for'. It could include format or examples, but the meaning is clear.

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 ('Retrieve') and resource ('country/region settings for a specific site'). It is clearly distinguishable from sibling tools like add_country_region_settings and remove_country_region_settings.

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 context is clear: use this when you need the country/region settings for a single site_url. It does not explicitly list alternatives or exclusions, but the retrieval scope is unambiguous.

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, but the description documents the return type and a BingWebmasterError failure mode, and the 'get' name implies read-only. It doesn't disclose permissions, rate limits, or whether the site must be verified, leaving the safety profile partly implicit.

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 uses a clear Args/Returns/Raises structure with the main purpose front-loaded. The 'This helps identify...' sentence is useful but slightly overlapping with the first sentence, so it isn't flawless.

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

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

For a one-parameter read-only tool with an output schema, the description covers purpose, argument, return, and error behavior. It is missing only richer site_url constraints and alternative-tool routing, which are minor at this complexity.

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 carry the parameter semantics, but the Args section only restates the schema ('site_url: The URL of the site') without adding format, verification requirements, or an example. The parameter is simple, but no extra meaning is added.

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

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

The opening sentence states a precise action and resource: 'Get a list of URLs with crawl issues for a specific site.' The second sentence clarifies the value ('pages that Bing's crawler had trouble accessing or processing') and distinguishes it from sibling tools like get_crawl_stats and get_crawl_settings.

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

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

The description gives a clear use case: use it to identify pages that Bing's crawler had trouble accessing or processing. It does not mention exclusions or name a sibling alternative, so it falls short of explicit when-not-to-use guidance.

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

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

With no annotations, the description makes the read-only nature clear via 'Retrieve' and 'current crawl settings,' and it discloses that failures surface as BingWebmasterError. It stops short of explaining side effects, ownership/prerequisite checks, or response details, but those are less critical for a simple getter.

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

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

The main action appears in the first sentence with no filler. The Args/Returns/Raises sections are compact and front-loaded, making it easy for an agent to scan.

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

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

For a one-parameter getter, the description covers purpose, the parameter, the return type, and a failure mode, which is sufficient for most invocation scenarios. It is only missing optional context like site verification requirements or how this relates to save_crawl_settings.

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 Args section defines site_url as 'the URL of the site,' which clarifies the single parameter despite the schema having no descriptions. It still largely paraphrases the parameter name and adds no format, scope, or validation details.

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

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

The description opens with 'Retrieve crawl settings for a specific site,' providing a clear verb, object, and scope. It distinguishes itself from the read/write sibling save_crawl_settings by the explicit retrieval framing, though it does not directly name that alternative.

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 prefer this tool over related settings tools or what conditions must be true before calling it. The name and verb imply a read operation, but no context, prerequisites, or typical workflow is offered.

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 burden of behavioral disclosure. It does disclose the return shape (List[CrawlStats]) and the possible error (BingWebmasterError), which is useful. It does not mention side effects, permissions, rate limits, pagination, or how the claimed date range is controlled.

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 well organized into Args, Returns, and Raises, with the main action in the first sentence. It contains one redundant line (the Args entry) but no filler or repetition elsewhere.

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 low complexity, the description is incomplete: it claims a date range but provides no parameter or mechanism for it, and it gives no guidance about what happens if no date range is specified. For one required parameter the tool is callable, but the mismatch between description and schema makes it less safe for an agent to invoke correctly.

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

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

The schema has no descriptions, so the description must add meaning. It only repeats the parameter name as 'The URL of the site', which adds no information beyond the property name site_url. There is no format, example, or clarification of the date-range behavior, leaving the only parameter semantically hollow.

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 uses a specific verb ('Retrieve') and names a concrete resource ('crawl statistics') scoped to a site. It is distinguishable from sibling tools like get_crawl_settings and get_crawl_issues. However, the phrase 'within a date range' is not reflected in the input schema, introducing 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?

The description gives no guidance on when to prefer this over alternatives such as get_crawl_settings, get_crawl_issues, or get_rank_and_traffic_stats, nor does it state any exclusions or preconditions. The only usage signal is the implicit one from the tool's name and first sentence.

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

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

Annotations are absent, so the description carries the full burden. It does disclose the return type (List[DeepLink]) and a raised exception (BingWebmasterError), which is helpful, but it doesn't describe read-only semantics, pagination, or any other side effects. For a no-annotation tool this is average but not thorough.

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 uses a compact Args/Returns/Raises structure that is easy to scan, with the core purpose stated in one sentence. It avoids fluff, though the bullet-style format is slightly more elaborate than necessary for a two-parameter tool.

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

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

The output schema exists, so return values are covered elsewhere. However, for a deprecated tool, the description lacks a recommended alternative and doesn't clarify what an 'algo URL' is or how it relates to other deep-link tools. Given the low parameter documentation, agents need more contextual guidance than this to use 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%, so the description must compensate, but it only provides terse one-line explanations for each parameter ('The URL of the site' and 'The specific URL to get deep links for'). The difference between 'site_url' and 'url' remains ambiguous, and there are no formats, examples, or value constraints, which is insufficient at this coverage level.

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 a specific action ('Get deep links') and resource ('specific algo URL'), adding a deprecation notice that helps agents know to avoid it. However, it does not explicitly differentiate itself from related siblings like get_deep_link_algo_urls and get_deep_link_blocks, so an agent may still conflate 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?

No guidance is provided on when to use this tool versus the many deep-link and deprecation alternatives. The deprecated notice hints at caution but does not point to a recommended replacement such as get_deep_link_algo_urls, leaving the agent to infer migration paths.

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?

There are no annotations, so the description carries the behavioral disclosure burden. It does disclose deprecation and the possible exception type (BingWebmasterError), but it doesn't mention side effects, permissions, rate limits, or whether the operation is read-only.

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 clearly structured with Args, Returns, and Raises sections. The deprecation note is placed up front, and there is no redundant 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?

For a one-parameter deprecation tool, the definition is mostly complete, especially with the output schema present. However, it fails to explain what "algo URLs" are or direct the user to a non-deprecated alternative, which an agent would need for real-world invocation.

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

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

The schema has 0% description coverage, so the description must add meaning for the parameter. It only restates "site_url: The URL of the site," which adds little beyond the parameter name and leaves open questions about required format or preconditions.

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 clear verb+resource: "Get algo URLs with deep links." It is reasonably specific and the Args/Returns block clarifies the input and output, though it doesn't contrast itself with sibling tools like get_deep_link.

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 about when to use this tool versus alternatives. The tool is marked "Deprecated," but no replacement tool is named, so the agent is left without a recommended migration path.

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 provides only an implicit read-only operation and a generic Raises clause. It does not mention side effects, permissions, rate limits, or what differentiates this retrieval call behaviorally from get_deep_link.

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, starts with the core action, and separates Args, Returns, and Raises cleanly. It has no filler or redundant sentences, though the parameter explanation is minimally informative.

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

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

For a one-parameter getter with an output schema, the description is mostly sufficient to make the call, but it does not clarify what deep link blocks are or how they differ from related tools such as add_page_preview/get_deep_link, leaving the agent reliant on the schema and naming.

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 coverage, the burden falls entirely on the description, but 'site_url: The URL of the site' is near-tautological and adds little beyond the parameter name. It does not specify URL format, requiredness nuance, or any 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 states a clear action and resource: 'Get deep link blocks for a site.' This distinguishes the verb and scope, though it does not explain what a deep link block is or how it differs from the sibling get_deep_link tool.

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 given on when to use this tool versus alternatives like get_deep_link or remove_deep_link_block. An agent would have no information about trade-offs or conditions favoring this call.

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 states it returns List[Feed] and raises BingWebmasterError, which is useful, but it doesn't disclose whether this is a read-only operation, whether it requires specific permissions, or any rate limits. The return type is partially disclosed but the behavior beyond that is opaque.

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

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

The description is concise and front-loaded with the main purpose. The Args/Returns/Raises structure is clear and scannable. However, the Returns section is redundant with the output schema, and the Raises section is generic. Still, it's efficient and well-organized.

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 and only 2 simple parameters, the description is mostly complete for basic invocation. However, it lacks context on when to use it, what 'detailed information' means beyond the schema, and any behavioral caveats. For a simple read tool, this is adequate but with 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?

Schema description coverage is 0%, so the description must compensate. It lists the two parameters (site_url and feed_url) with brief descriptions ('The URL of the site', 'The URL of the feed'), which adds minimal meaning beyond the schema's type and title. It doesn't explain formats, whether they must be exact matches, or how they relate to each other. Baseline 3 is appropriate since the description does add some semantic value but not much.

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 clear verb and resource: 'Get detailed information about a specific feed.' It distinguishes itself from sibling tools like get_feeds (which likely lists feeds) and remove_feed (which deletes). However, it doesn't explicitly differentiate from get_fetched_url_details or other detail-retrieval tools, so it's clear but not fully differentiated.

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. It doesn't mention that get_feeds should be used to list feeds first, or that this tool is for a specific feed's details. No exclusions or alternative conditions 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 full burden. It discloses the return type (List[Feed]) and that it raises BingWebmasterError on failure, which adds useful behavioral context. However, it does not explicitly state whether the operation is read-only, whether site verification is required, or any rate limits. The 'get' verb implies read-only but does not disclose the full behavioral profile.

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 well-structured. The purpose is front-loaded in the first sentence, followed by clearly labeled Args, Returns, and Raises sections. Every line adds value, with no redundancy 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?

Given the tool is a single-parameter read operation with an output schema (List[Feed]), the description covers the essential context: what it returns and the error condition. It does not mention prerequisites like site verification or access roles, which could matter for an agent selecting the tool, but the core calling information is complete. The presence of an output schema reduces the need to explain return values in detail.

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 does so by documenting the parameter: 'site_url: The URL of the site'. This gives the parameter meaning beyond the bare schema definition, though it is minimal and could elaborate on format or requirements (e.g., full URL with protocol).

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 ('Get') and resource ('all sitemap feeds'), scoped to 'a site'. This clearly distinguishes it from siblings like get_feed_details (which likely targets one feed) and submit_feed/remove_feed (mutations). An agent can tell exactly what this tool does without needing to inspect other definitions.

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 usage is implied: use this when you need all sitemap feeds for a site. However, it does not explicitly mention alternatives or conditions, such as 'for a specific feed use get_feed_details' or 'when your site is already verified'. There is no when-not-to-use guidance, so the agent must infer the appropriate use case from the purpose alone.

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 states what the tool returns (FetchedUrlDetails) and that it raises BingWebmasterError, adding some behavioral transparency. However, with no annotations, it does not disclose side effects, permission requirements, rate limits, or what 'fetched' status implies. It is a read operation by name but this is not explicitly stated.

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: one summary sentence, then Args, Returns, and Raises sections, each with a single line. No filler or repetition beyond the weak site_url 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?

With an output schema absent and many sibling tools present, the description does not explain how this relates to fetch_url or get_fetched_urls, nor what conditions must hold (e.g., URL must have been fetched). It gives the essentials but leaves relationship and return-structure details unsaid.

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 lists both args but site_url's description ('The URL of the site') is nearly tautological jew and url's ('The specific URL to get details for') merely restates the tool's purpose. Basic placeholder semantics, not enough to resolve ambiguity.

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 'Get detailed information about a specific fetched URL' gives a clear verb and resource. It is distinct from siblings like fetch_url and get_fetched_urls, though it does not explicitly call out that distinction. Overall purpose 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?

No guidance is provided about when to use this tool versus related siblings (fetch_url, get_fetched_urls). There is no mention of prerequisites, such as the URL needing to have been previously fetched or being associated with the given site_url.

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 states the operation is read-only (via 'Get'), returns a List[FetchedUrl] with status, and raises a BingWebmasterError on failure. However, it does not disclose potential rate limits, pagination, or any side effects. It is adequate but not comprehensive for a tool with zero annotation coverage.

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 exceptionally concise and well-structured: a one-line summary followed by Args, Returns, and Raises sections. It is front-loaded with the purpose and contains no filler. Every sentence earns its place.

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

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

For a simple one-parameter tool with an output schema, the description covers purpose, parameter, return type, and error behavior. It lacks explicit usage guidance and alternative routing, but those are addressed in other dimensions. Given the low complexity, it is fairly complete for an agent 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%, so the description must compensate. It only provides 'site_url: The URL of the site,' which adds negligible meaning beyond the parameter name. No format, examples, or constraints are given. This is insufficient for an agent to correctly construct a valid site_url value.

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 starts with a clear verb+resource: 'Get a list of URLs that have been submitted for fetching.' This unambiguously distinguishes it from siblings like fetch_url (initiates a fetch) and get_fetched_url_details (details of a single fetched URL). The purpose is specific and immediately understood.

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

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

The description clearly implies when to use this tool (when you need a list of fetched URLs) but does not explicitly mention alternatives or exclusion criteria. It lacks guidance like 'use get_fetched_url_details for individual URL details' or 'use submit_url to submit new URLs.' The context is clear but no explicit routing is provided.

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 transparency burden. It does disclose return behavior ('Optional[Keyword]' and 'None if no data available') and the BingWebmasterTools exception, which is useful. However, it does not mention whether this operation has side effects, requires special permissions, or any peculiarities of the returned keyword impression data.

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

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

The description is compact and front-loaded, with a one-sentence summary followed by clearly separated Args/Returns/Raises sections. It avoids redundancy and is easy to parse, though it could be more concise in the parameter descriptions.

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 inputs, return type, and failure behavior, which is adequate for a simple lookup tool. However, it does not explain when to prefer this over similar keyword/query tools, nor does it clarify any prerequisites or expected input formats beyond the schema, leaving some contextual ambiguity.

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 no descriptions, so the Args section carries the burden. It explains each of the five parameters, but only superficially: 'The country code' and 'The language code' add some meaning, while 'query' and the date parameters are near-tautological and lack format or constraint details such as expected date formats or language code standards.

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 clearly states the operation ('Get keyword impressions') and the primary scope ('for a selected period'). It is clear enough on its own but does not distinguish itself from the many sibling tools like get_keyword_stats or get_related_keywords.

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 about when to use this tool versus alternatives such as get_keyword_stats, get_related_keywords, or get_query_stats. The description simply restates the function rather than explaining its specific use case.

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. It does disclose the return type (List[KeywordStats]) and a specific error condition (BingWebmasterError), which is useful. However, it does not discuss side effects, rate limits, auth requirements, or what happens when no statistics exist.

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 well-organized with clear Args, Returns, and Raises sections. The summary line is front-loaded, and no sentence is filler. Slight redundancy exists between the summary and Returns line, but overall it is efficiently structured.

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 gives the necessary parameters, examples, return type, and error behavior, which is sufficient for basic invocation. The presence of an output schema reduces the need to explain return values. Still, given a large set of similar statistics-gathering sibling tools, the absence of contextual orientation makes it incomplete in a broader operational setting.

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 defines each parameter briefly and gives concrete examples for country ('gb') and language ('en-GB'), which adds practical value beyond the bare schema. It could still specify valid values or constraints, but it covers all three parameters meaningfully.

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 action and resource: 'Retrieve keyword statistics for a specific query.' This is clear and not a tautology. However, it does not distinguish itself from similar siblings like get_query_stats or get_keyword_stats, leaving the differential purpose somewhat ambiguous.

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 about when to use this tool instead of alternatives. It does not mention any exclusions, prerequisites, or comparison to sibling tools, so an agent must infer usage from the name alone.

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

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

With no annotations provided, the description must disclose behavioral traits. It states it 'Retrieve's data and raises a BingWebmasterError on failure, implying a read-only operation and an error condition. However, it does not mention rate limits, authentication requirements, or any side effects. The description covers basic behavior but lacks depth, so a 3 is appropriate.

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 purpose, then clearly labeled Args, Returns, and Raises sections. Every sentence adds value, and the structure front-loads the core action. There is no redundancy or unnecessary prose, making it highly efficient.

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

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

For a simple retrieval tool with an output schema available, the description covers the essential aspects: the parameters, the return type, and the error case. However, it omits details such as pagination semantics (e.g., what page 0 means, page size) and does not mention any constraints on site_url format. The presence of an output schema reduces the need to explain return structure, but the description still leaves some operational details unclear.

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, so the description carries the full burden for parameter meaning. It provides clear explanations for both site_url ('The URL of the site') and page ('The page number of results to retrieve'). While not extremely detailed, it adds meaningful context beyond the schema's bare types and constraints, warranting a 4.

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 (retrieve) and the resource (link counts for a specific site), which is specific enough to understand the core purpose. It does not explicitly differentiate from sibling tools like get_url_links, but the wording is unambiguous. The verb and resource are distinct, earning a 4 rather than 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?

The description gives no guidance on when to use this tool versus alternatives such as get_url_links or get_children_url_info. It does not state prerequisites, exclusions, or conditions that would select this tool. The only usage hint is the parameter description, which is not explicit enough for tool selection.

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 return type (List[QueryStats]) and a possible error, but does not explicitly state that the operation is read-only or mention any side effects, permissions, or limitations. It is minimal but acceptable for a simple 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 well-structured with a clear main sentence followed by Args, Returns, and Raises sections. It is concise, with no redundant information, and the primary purpose is front-loaded. The formatting is consistent and scannable.

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 only two simple parameters and an output schema, the description covers the basics. However, it fails to address the high number of sibling tools that could be confused with this one. An agent may not know when to select this over get_page_stats or get_query_page_stats. This omission reduces 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?

The schema has no descriptions (0% coverage), so the description compensates by providing one-line explanations for both parameters: site_url is 'The URL of the site' and page is 'The specific page URL to get statistics for'. This adds meaning beyond the bare names, though it lacks details like URL format or 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 states a clear purpose: retrieving detailed traffic statistics for a specific page. It uses a specific verb ('Get') and identifies the resource ('traffic statistics for a specific page'). However, it does not differentiate from siblings like get_page_stats or get_query_page_stats, which could also apply. The phrase 'detailed traffic statistics' hints at a distinction but leaves 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?

There is no guidance on when to use this tool versus alternatives. The description does not mention conditions, exclusions, or preferred scenarios. Given the numerous similar statistics tools in the sibling list, this lack of routing information is a significant gap.

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 the return type and a raised error. However, it does not mention authorization requirements, data source, refresh behavior, or any limits on the 'top pages' result set.

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 uses a clear Args/Returns/Raises structure with the main action front-loaded. It loses a point because the Returns section says 'query statistics' for a page-stats tool, which introduces slight ambiguity.

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 large sibling set of stats tools, the description lacks enough context to help an agent choose between get_page_stats, get_query_stats, get_page_query_stats, and similar endpoints. It provides a site_url parameter and return type, but no decision-relevant distinctions.

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 only states site_url is a string, and the description adds only 'The URL of the site'. This adds minimal meaning and does not specify expected format, whether it must be a verified site, or how it relates to the returned stats.

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 clear action and resource: 'Get detailed traffic statistics for top pages.' This distinguishes the tool from site-level management siblings, though it does not explicitly differentiate it from closely related stats tools like get_page_query_stats or get_query_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 is provided on when to choose this tool over sibling statistics tools. It does not mention exclusions, prerequisites, or how this differs from query-level or page-query stats endpoints.

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 of behavioral disclosure. The description does disclose it raises BingWebmasterError and returns a list, but it does not explain any side effects, access requirements, rate limits, or whether the data is real-time or rolled-up. This is thin for a read-only statistics tool with zero annotations.

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

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

The purpose sentence is front-loaded, and the Args/Returns/Raises sections are short and clean. But those sections are standard boilerplate that mostly repeat the schema and output schema, carrying little additional information while occupying most of the description.

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 having an output schema covers the return shape, but the surrounding context is inadequate. The tool's purpose is ambiguous relative to a large sibling cluster, and the parameters are not explained. An agent cannot confidently select or successfully call this tool without seeking additional information elsewhere.

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. The Args section just repeats the parameter names with no added meaning: 'site_url: The URL of the site' is only a rewording of the name. No format, constraints, example, or relationship between the three required parameters is provided.

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

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

The description states a specific verb and resource: 'Get detailed statistics for a specific query and page combination.' This is clear on its surface. However, it does not distinguish itself from closely named siblings like get_query_page_stats, get_page_query_stats, or get_query_traffic_stats, so an agent cannot tell what makes these statistics 'detailed' or unique.

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 given on when to use this tool versus the many similar sibling statistics tools. With at least seven sibling tools that appear to return query/page statistics, the absence of any scoping or alternative references leaves usage entirely to inference.

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 that the tool returns a List[QueryStats] and raises a BingWebmasterError, but it does not clarify whether the operation is read-only (implied by 'get'), any authentication requirements, rate limits, or what happens when the query yields no matches. For a read-only analytics tool, more context is needed to set agent expectations.

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

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

The description is concise and follows a clear docstring structure (Args, Returns, Raises). It is front-loaded with the core purpose and avoids extraneous prose. While it could include more detail, the brevity is appropriate for a tool with only two parameters and a straightforward operation.

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 the tool has an output schema (not shown in the definition), the description provides minimal context beyond the return type. It omits any mention of required permissions, rate limits, or the relationship to sibling tools like get_query_page_detail_stats. For a tool that returns 'detailed traffic statistics,' the description lacks enough context for an agent to know when this is the appropriate choice or what to expect in edge cases.

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 lists site_url and query but provides no additional meaning—no format constraints, examples, or clarification of what 'query' refers to (e.g., exact match vs. substring). The parameters are self-explanatory by name, but the description adds no value beyond the schema's property titles.

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: 'Get detailed traffic statistics for pages matching a specific query.' This specifies a verb (get), resource (traffic statistics for pages), and context (query-based filtering). It distinguishes itself from sibling tools like get_query_stats and get_page_stats by focusing on page-level detail for a specific query, but it doesn't explicitly name alternatives or contrast its scope.

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 its many siblings (e.g., get_query_page_detail_stats, get_query_traffic_stats). The description does not state prerequisites, conditions for selection, or exclusions. An agent would have to infer usage from the name alone, which is insufficient given the crowded tool family.

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

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

Annotations are absent, so the description must carry the burden. It reveals a read operation and mentions possible errors, but doesn't cover whether site_url must be verified or whether the list is sorted or complete. The risk of mutation is low, but the description 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 structured with clear sections (Args, Returns, Raises), making it easy to scan. However, it includes boilerplate text like 'Args:' that is already implied by the schema, and the description repeats the parameter information without adding value.

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

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

With an output schema present, the return type is covered. The single parameter is simple combativeness the description explains it. Missing are any edge cases or prerequisites (e.g., site must be verified). It's adequate but not rich.

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 the description explicitly explains the 'site_url' parameter's purpose and provides an Args section. It adds meaning beyond the schema, though it doesn't detail the format or constraints beyond type string.

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 URL normalization parameters for a site, which distinguishes it from sibling tools like add_query_parameter and remove_query_parameter. The purpose is specific and the resource is named.

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 role of URL parameters in normalization, giving context on why one might use this tool Edited whether to use alternatives is not explicit, but the context implies a read operation for configuration. No direct comparison to sibling tools is provided.

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

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

Annotations are absent, so the description carries the full burden. It does disclose the return type and a possible exception, but it omits prerequisites, authentication needs, rate limits, pagination, sorting, or what 'top' means. This is minimal behavioral disclosure for an unannotated 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 short and cleanly structured with Summary, Args, Returns, and Raises sections. The first sentence and Returns line repeat 'top queries' slightly, but there is no wasted 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?

For a one-parameter tool with an output schema, the description provides enough to attempt a call, including return type and error behavior. However, it lacks context for selecting this tool among similar query-statistics siblings and omits prerequisites such as site verification or data availability.

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 description says 'site_url: The URL of the site', which essentially restates the schema title 'Site Url' and the parameter name. It adds no format, example, constraints, or clarification beyond what the schema already communicates, and schema description coverage is 0%, so the description should compensate more.

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 clear verb and resource: 'Get detailed traffic statistics for top queries.' This is specific enough to communicate the core operation, but it does not distinguish this tool from very similar siblings like get_query_traffic_stats, get_query_page_stats, or get_rank_and_traffic_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 given about when to use this tool instead of the many similar query-statistics siblings. Terms like 'top queries' are not defined, and there are no exclusions, prerequisites, or alternative tool references.

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?

There are no annotations, so the description carries the burden of disclosing behavior. It does state that the tool returns a list of traffic statistics and raises BingWebmasterError on failure. It misses broader context such as site verification requirements, permission needs, or other behavioral constraints, but for a read-only 'get' tool this is a minimally workable disclosure.

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 structured with clear Args, Returns, and Raises sections. It contains no filler or redundant restatement of the schema, and the one-line summary is sufficient to convey the tool's core function.

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

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

The tool is simple, has only two parameters, and has an output schema, so the description does not need to explain return shapes in detail. It is still not fully complete because it fails to position the tool among its many query-statistics siblings and omits conditions like site verification or prerequisites.

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

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

Schema description coverage is 0%, so this description is the only source of parameter meaning. It defines site_url as the URL of the site and query as the search query, which is enough for agents to understand the two required parameters, even though it adds no format, size, or constraint information.

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 clear action and scope: getting detailed traffic statistics for a specific query. However, it does not distinguish itself from closely related sibling tools such as get_query_stats, get_query_page_stats, or get_rank_and_traffic_stats, which leaves some ambiguity for tool selection.

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 summary and mentions arg names, but it gives no guidance about when to choose this tool over similar query-statistics tools. It also notes no exclusions, prerequisites, or alternatives, so an agent has to infer the right choice from the name alone.

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?

There are no annotations, so the description carries the burden. It does disclose a specific failure mode (raises BingWebmasterError) and that it returns a list, which adds some transparency. However, it does not mention side effects, permissions, rate limits, or data freshness.

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 structure is clean, front-loaded, and compact: summary, Args, Returns, Raises. It is not verbose, though the Returns section largely duplicates what an output schema would provide.

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

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

For a one-parameter read-only lookup, it covers the essentials: parameter, return type, and an error condition. However, it lacks any usage context or clarification of scope relative to sibling stats tools, and with no annotations it could be more explicit about expected 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 coverage is 0%, but the description only restates the obvious: site_url is 'The URL of the site.' It does not clarify required format (e.g., with or without protocol), whether the site must be a verified property, or any constraints on the 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 a specific action and resource: 'Get ranking and traffic statistics for a site.' It is more than a restatement of the name)Skip, though it does not explicitly differentiate itself from similar sibling tools like get_query_stats or get_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 is given about when to use this tool versus the many sibling statistics/reporting tools, nor about prerequisites or expected context. It only describes what the function does and returns.

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 does state the return type (List[Keyword]) and the error raised (BingWebmasterError), which is useful. However, it does not disclose whether the operation is read-only, any authorization requirements, rate limits, or pagination behavior. Since it is a 'get' operation, these are likely non-issues, but the lack of explicit disclosure is a moderate gap.

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

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

The description is well-structured and concise. It opens with a one-sentence summary, then uses clear sections for Args, Returns, and Raises. There is no fluff, and the most important information is front-loaded. This is an excellent example of efficient, organized documentation.

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 get operation with five parameters, the description covers the essential aspects: purpose, arguments, return type, and error handling. The presence of an output schema likely documents the return structure in detail, so the description doesn't need to. It lacks explicit usage context (when to use vs. alternatives), but that is already scored under usage guidelines. Overall, it is reasonably complete for the tool's complexity.

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 does provide brief explanations for each parameter: query, country, language, start_date, end_date. These add basic meaning beyond the bare schema titles, but they lack details like expected formats (e.g., ISO codes for country/language, date format beyond the schema's date-time hint). This is sufficient but not thorough.

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: 'Get keyword impressions for related keywords in the selected period.' It uses a specific verb and resource, and the mention of 'related keywords' distinguishes it from sibling tools like get_keyword or get_keyword_stats, though it doesn't explicitly name 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 provides no guidance on when to use this tool versus alternatives. It does not mention any conditions for selection, nor does it reference sibling tools. The agent is left to infer that it should be used for related keyword exploration, but no explicit usage guidance is 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that it returns a list of SiteMoveSettings and raises a BingWebmasterError on failure, but it does not explicitly confirm it is read-only, mention any permissions or side effects, or describe the structure of the returned list. Minimal transparency beyond the error case.

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 with explicit Args, Returns, and Raises sections. It contains no fluff and is appropriately sized for a simple getter. However, it could be slightly more informative about usage context without becoming verbose.

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 and the presence of an output schema, the description is adequate but not complete. It lacks any mention of when to use this tool relative to siblings, such as the relationship with submit_site_move. It also does not indicate whether the site must be verified or any other preconditions. The error case is covered, but broader context is missing.

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

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

The schema has zero description coverage for the site_url parameter, but the description explicitly documents it as 'The URL of the site'. This adds meaning that the schema lacks. The return type is also specified, giving clarity on what the parameter influences.

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 clear verb (get) and resource (site move information) scoped to a specific site. It is distinguishable from siblings like submit_site_move, but it does not explicitly name an alternative or contrast itself. The purpose 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?

No guidance is given on when to use this tool versus alternatives such as submit_site_move or other getter tools. The description does not mention prerequisites, typical use cases, or conditions that would make this the right choice. It only describes the action itself.

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 discloses the return type (List[SiteRole]), error behavior (raises BingWebmasterError), and explains the meaning of both parameters in the Args section. While it doesn't mention side effects (as it's a read operation, 'get' implies non-mutating), it provides sufficient 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 a well-structured docstring with a clear one-sentence purpose, followed by Args, Returns, and Raises sections. It is concise with no fluff, and the key purpose is front-loaded.

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

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

For a simple get tool with only 2 parameters and an output schema, the description covers purpose, parameters, return, and errors. It doesn't mention prerequisites or relationship to sibling tools, but that's not essential for a straightforward retrieval operation. The output schema exists, so the description doesn't need to detail the structure further.

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 does so by explaining each parameter: 'site_url: The URL of the site' and 'include_all_subdomains: Whether to include roles for all subdomains'. This adds meaning beyond the bare type/title in the schema, though it could be more specific about URL format or default behavior.

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 ('Get') and resource ('all roles assigned for a specific site'), clearly distinguishing it from sibling tools like add_site_roles and remove_site_role. The purpose is unambiguous and immediately understandable.

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, such as when retrieving roles before modifying them or checking existing permissions. It simply states what it does without any context 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?

With no annotations, the description still communicates that this is a retrieval operation, returns a list of sites, and raises a BingWebmasterError on failure. It does not mention pagination or authentication, but this is a simple zero-parameter list operation.

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

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

The description is short, front-loaded with the core action, and uses clearly labeled Returns and Raises sections. It is easy for an agent to parse quickly.

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 essential context: what the tool does, what it returns, and what error type may be raised. Since an output schema is present, the return structure does not need to be spelled out further, and no parameters require explanation.

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, so the parameter semantic burden is minimal. The phrase 'all sites' clarifies that the scope is account-wide, which is the only meaningful guidance needed.

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

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

The description uses a specific verb and resource: it retrieves all sites in the user's Bing Webmaster Tools account. This clearly distinguishes it from sibling tools that add, remove, or modify sites.

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 makes the intended use obvious—call this when you need the full list of sites for the account. However, it does not explicitly compare against or contrast with similar sibling tools like get_site_roles or site mutation endpoints.

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 transparency burden. It does disclose the return type (UrlInfo) and a failure mode (BingWebmasterError), and the verb 'Retrieve' implies a read-only operation. However, it provides no context about permissions, rate limits, or what specific aspects of the URL are covered.

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

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

The description is concise and well-structured with clear Args/Returns/Raises sections. Every section adds necessary information, and there is no redundant or filler content. The format makes the tool easy to parse quickly.

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

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

The output schema covers return values, so the description does not need to restate those. However, the description lacks guidance on when to use this tool over alternatives and does not clarify the difference between 'detailed information' and the more specific sibling tools, leaving some ambiguity for agents in a large toolset.

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 provides brief glosses for both parameters, distinguishing site_url from url, but lacks format details, examples, or clarification of how the two parameters interact. This is minimal but sufficient for basic 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 a specific action ('Retrieve detailed information') applied to a specific resource ('a specific URL'). This distinguishes it from broader site-level tools, but it does not explicitly differentiate it from closely related siblings like get_url_traffic_info or get_children_url_info.

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 only explains what the tool does and its parameters, leaving an agent to infer appropriate usage from the 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 to lean on, the description carries the full burden. It does disclose read-only retrieval semantics, pagination through the page argument, and a possible error via 'Raises: BingWebmasterError', which adds some behavioral context, but it does not mention permissions, rate limits, or result-page 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 compact, clearly organized into Args, Returns, and Raises sections, and contains no filler. Every sentence contributes 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?

For a simple read operation with an output schema and no nested objects, the description covers the essential invocation details: parameters, return type, and error condition. It is complete enough for an agent to call it correctly, though it lacks usage guidance.

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. The Args section provides a meaningful one-line explanation for each parameter, especially clarifying that 'link' is the URL whose inbound links are being retrieved.

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 a specific verb and resource: 'Retrieve inbound links for a specific URL.' It is distinct enough from most siblings, though it does not explicitly contrast itself with similar tools like get_link_counts or get_url_info.

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 about when to use this tool versus alternatives such as get_link_counts or get_url_info. The description gives the operation but not the decision 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?

Given no annotations, the description carries the burden of behavioral disclosure. It implies a read-only operation ('Get information'), and it mentions an error type ('Raises: BingWebmasterError') which adds some transparency. However, it does not explicitly state that it is non-destructive, does not describe any side effects, rate limits, or failure conditions beyond the generic error. This is minimal but provides basic clarity.

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, front-loaded with the main purpose, and uses a clear Args/Returns/Raises structure. Every section is relevant and there is no fluff. It earns a high score for efficiency, though it could be more informative without losing conciseness.

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

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

For a simple tool with one parameter and an output schema, the description covers the basic return and error. However, it does not mention when to use this quota tool versus the sibling 'get_content_submission_quota', and it does not explain the meaning of the returned quota in context. Given the simplicity of the tool, it is adequate but not 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 description coverage is 0%, so the description must compensate for the parameter 'site_url'. The description only states 'The URL of the site', which is essentially a restatement of the parameter name and lacks details such as required format (e.g., protocol, domain), validation rules, or examples. For a single parameter with no schema guidance, this is insufficient.

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: 'Get information about URL submission quota and usage.' The verb 'Get' and the resource 'URL submission quota' are specific and unambiguous. It distinguishes from broader site management tools but does not explicitly differentiate from the sibling 'get_content_submission_quota', which is a similar quota-retrieval tool for content, so a small deduction.

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. The description does not mention any context, prerequisites, or tell the agent when to pick this over 'get_content_submission_quota' or other quota-related tools. It merely states the function, leaving the agent to infer usage.

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 implies a read-only operation via 'Get', but does not explicitly state that it has no side effects, does not mention authentication requirements, rate limits, or what happens when the URL is invalid or not found. The Raises clause only mentions error handling, not behavioral traits.

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 with clear Args/Returns/Raises sections, which is good. However, the content within those sections is repetitive with the schema and provides little additional value. It is not overlong, but it does not use its brevity effectively to convey essential distinctions.

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

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

Given the tool's complexity and the existence of an output schema, the description still lacks crucial context. It does not specify what traffic metrics are returned (e.g., clicks, impressions, position), whether a date range is involved, or how this differs from get_page_stats and get_rank_and_traffic_stats. Without this, an agent cannot confidently select or correctly invoke the 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 description coverage is 0%, so the description must compensate. The Args section provides brief explanations ('site_url: The URL of the site', 'url: The specific URL to get traffic info for'), but these are largely tautological, restating the parameter names without adding format constraints, required patterns, or relationships. The description adds minimal meaning 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 states 'Get traffic details for a single page' which is a clear verb+resource. It identifies the tool as fetching traffic information for one URL. However, it does not differentiate from many siblings like get_page_stats, get_rank_and_traffic_stats, or get_url_info, which also target single pages, so it lacks the specificity needed to distinguish it in this crowded space.

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 its many siblings. It does not mention alternatives, exclusions, or context for selection. The description only restates the purpose without indicating scenarios where this tool is preferred, leaving an agent to guess among dozens of similar 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. It discloses that a BingWebmasterError is raised if the URL cannot be unblocked, which is useful. However, it does not mention the destructive nature explicitly, success behavior, or any side effects beyond removal. It is partially transparent but lacks depth.

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-line purpose, a clear argument list, and a Raises section. It is front-loaded and each element earns its place 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 there is an output schema (not shown) and the tool is relatively simple, the description covers the arguments and errors. However, it does not explain the practical differences between CacheOnly and FullRemoval, nor any prerequisites like site verification. For correct invocation, an agent might need more context, so completeness is moderate.

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 explain the parameters. It does: site_url and blocked_url are straightforward, and entity_type and request_type are given labels (Page/Directory, CacheOnly/FullRemoval) that the schema lacks (only integer enums). date is described but its role is ambiguous. This meaningfully adds to the schema, though not exhaustively.

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: 'Remove a blocked URL from a site.' This is a specific verb+resource combination that immediately distinguishes it from sibling tools like add_blocked_url and get_blocked_urls. The list of arguments further clarifies the operation.

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 (remove instead of add), but it does not explicitly state when to use this tool versus alternatives. There is no mention of prerequisites, such as the URL must already be blocked, or when to use a different removal method. The guidance is adequate but not explicit.

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. It mentions `Raises: BingWebmasterError` but does not disclose other behavioral aspects: whether removal is permanent, if there are side effects, rate limits, or required permissions. It also doesn't describe the return value, which is crucial for a mutation operation.

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

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

The description is concise with a docstring format, listing parameters and exceptions. It's appropriately sized for the tool's complexity. However, the parameter descriptions are minimal, and the Raises section could be more informative, but overall it's 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 the tool has a nested object parameter (`settings` with a defined schema) and no annotations, the description is incomplete. It doesn't explain the structure of `settings` or how to construct it for removal, nor does it describe the return value or side effects. The output schema exists but is not referenced. It's adequate but has 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?

Schema description coverage is 0%, so the description must compensate. The description lists the two parameters (site_url, settings) but provides no additional detail beyond their names. The schema defines `settings` as a complex object with a required structure, but the description does not explain how to specify the settings to remove, such as whether partial objects are accepted or which fields are needed.

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

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

The description states the verb 'Remove' and the resource 'country/region settings from a specific site', which is clear. It is distinguishable from siblings like 'add_country_region_settings' and 'get_country_region_settings' by the verb. However, it does not explicitly differentiate from other 'remove_' tools, but the resource is specific enough.

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 it is used to remove settings, but provides no explicit guidance on when to use this tool versus alternatives like 'add_country_region_settings' or 'get_country_region_settings'. It lacks context on prerequisites, such as whether the site must be verified or settings must exist.

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 add one useful behavioral detail: it raises BingWebmasterError if the block cannot be removed. However, it does not disclose whether removal is permanent, what authorization is required, or any side effects, so the transparency is partial.

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, organized into Args and Raises sections, and avoids unnecessary prose. It is appropriately sized for the tool, though the brevity contributes to some under-specification that is penalized elsewhere.

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 mutating tool with four required parameters, no annotations, and 0% schema description coverage, the description leaves too much unstated. It does not explain the success/return behavior, prerequisite conditions, parameter formats, or how this relates to get/add_deep_link_block, making it incomplete for an agent to call confidently.

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, but it mostly restates the parameter names: 'site_url: The URL of the site' and 'search_url: The search URL' add little meaning. Only 'deep_link_url: The deep link URL to unblock' and 'market: The market code' provide slight extra context, with no format or acceptable-value details.

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

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

The opening phrase 'Remove a deep link block' is a specific verb+resource statement, and the Args section clarifies that the deep_link_url is the URL to unblock. This distinguishes it from sibling tools like add_deep_link_block, get_deep_link_blocks, and update_deep_link by the removal action alone.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites such as the block existing or being discoverable via get_deep_link_blocks. The only contextual signal is the 'to unblock' wording, which implies but does not state the intended workflow.

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 responsibility for disclosing behavior. It only states the action and that an error is raised on failure, but does not mention side effects, idempotency, permission requirements, or impact on other data. This is insufficient for a destructive operation.

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

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

The description is concise and well-structured with an Args and Raises section. It front-loads the purpose and includes only relevant information. No extraneous 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?

For a destructive operation with no annotations and no output schema details, the description is incomplete. It omits prerequisites (site must be verified, feed must exist), potential side effects, and return behavior. An agent would lack information needed to call it safely and 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 schema provides zero description coverage, so the description must define the parameters. It does give one-line definitions for both site_url and feed_url, which clarifies their purpose, but lacks detail on format or validation. It adds some meaning but does not fully 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 action ('Remove') and the resource ('previously submitted sitemap feed'), making the purpose unambiguous. It does not explicitly differentiate from sibling tools like remove_site or remove_blocked_url, but the resource is specific enough to avoid confusion.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor any prerequisites (e.g., the site must be verified, the feed must have been submitted via submit_feed). It simply states the action without 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It acknowledges the destructive 'Remove' action and mentions a BingWebmasterError, but it does not disclose prerequisites such as site ownership, whether the block must already exist, or whether removal is reversible.

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

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

The description is concise and front-loaded, with a one-sentence summary followed directly by the Args and Raises sections. There is no redundant or filler content; every line serves a clear purpose.

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 gives the operation, both required arguments, and an error condition, which is adequate for a simple two-parameter removal call. However, it omits usage context, permissions, and any connection to related preview-block tools, so an agent must infer operational 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 description coverage is 0%, so the parameter descriptions in the tool description are the only source of meaning. They distinguish site_url as 'the URL of the site' and url as the page from which to remove the preview block, but they provide no format, examples, or URL conventions, which leaves some ambiguity.

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 ('Remove') and explicit resource ('page preview block'), so the core operation is unambiguous. It does not explicitly differentiate itself from sibling tools like remove_deep_link_block or add_page_preview_block, but the resource name and arguments make the intent clear.

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

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

The description implies the tool is used when a page preview block should be removed, but it provides no explicit when-to-use or when-not-to-use guidance. No alternatives are mentioned, leaving the agent to infer the appropriate selection 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 must carry disclosure. It mentions a Raises condition but doesn't cover whether removal is permanent, whether the parameter must first exist, or any side effects. For a mutating operation this is thin.

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 purpose then Args/Raises blocks. No fluff; the action sentence is front-loaded.

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

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

Two required parameters, no output schema, no annotations. The description doesn't state what counts as a valid site_url or what 'remove' does to existing crawl data, and the Raises line lacks conditions beyond failure.

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 Args section just restates the parameter names with trivial glosses; with 0% schema coverage the description was expected to compensate with concrete formats or examples, and it doesn't.

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 action ('Remove') and resource ('a URL normalization parameter from a site'), making the core purpose unambiguous. It doesn't explicitly differentiate from the sibling enable_disable_query_parameter, but the verb 'remove' distinguishes it well enough in most contexts.

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 removal versus toggling via enable_disable_query_parameter, or what prerequisites exist (e.g., site must be added/verified). The usage context is only implied by the verb 'remove'.

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, so the description carries the full burden. It does disclose that a BingWebmasterError is raised if removal fails, which adds behavioral context. However, it does not mention whether removal is irreversible, whether site verification is required, or what associated data (e.g., roles, feeds, blocks) might be affected.

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 with the purpose, followed by parameter and error details in clean sections. No superfluous text exists; every line adds needed 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 one-parameter removal operation with an output schema present, the description covers the purpose, parameter, and error condition. It does not mention preconditions like site existence/verification or consequences of removal, but the operation is simple enough that an agent can call it correctly with the given information.

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's 'Args' section is essential. It clearly defines site_url as 'The URL of the site to remove,' giving the single parameter meaningful semantics beyond the schema's bare 'Site Url' title. It lacks format or example values, but for a simple URL string this is sufficient.

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 ('Remove') and a specific resource ('a site from Bing Webmaster Tools'), making the tool's core purpose unambiguous. It also differentiates from siblings like remove_site_role, remove_feed, and remove_blocked_url by referring to the site-level resource.

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 intended use is implied from 'Remove a site from Bing Webmaster Tools,' but there is no explicit guidance on when to choose this over alternatives, no prerequisites, and no mention of when not to use it. The sibling list suggests many removal/role tools, yet no differentiation is provided.

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?

There are no annotations, so the description carries the full burden for surfacing side effectscor. It discloses only that a BingWebmasterError is raised when removal fails. It does not state whether removal is destructive/permanent, whether the role object must match an existing role exactly, or how the user is identified (e.g., by Email in the site_role object).

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 followed by compact docstring fields. There is no redundancy or fluff; all lines serve a purpose (summary, args, raised error).

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