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

Description explicitly discloses async behavior, polling requirements (status 'FINISHED' before using ai_parser_parse_url), and potential ToolError conditions. Annotations (readOnlyHint=false, destructiveHint=false) align with a creation tool, and the description adds valuable behavioral context beyond 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?

Well-structured with clear sections (when to use, when not, args, returns, raises). The first sentence is effective. Minor redundancy with schema (Args section) but overall 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?

Covers all aspects: purpose, async workflow, polling, error types, prerequisites (example URLs), and return format. Given the tool's complexity, the description is comprehensive and leaves no critical 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?

Despite schema description coverage being 0%, the description summarizes the required params (name and urls) and optional ones (scraper_params, fields) with their purposes. This compensates for the schema gap, though the description could include more param-specific details found in the schema.

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

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

Description opens with a clear verb and resource: 'Create a reusable AI parser from example URLs.' It further distinguishes from siblings by contrasting with 'scrape' (one-off) and SDE (supported sites). The async nature is highlighted.

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

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

Explicit 'When to use' and 'When NOT to use' sections provide concrete guidance, including alternatives (scrape, SDE) and required polling pattern. Leaves no ambiguity about when to choose this tool.

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

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

Annotations already declare destructiveHint=true. Description adds context that deletion is permanent and removes all versions, and explains return value (empty string on 204). Does not contradict 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?

Concise with front-loaded purpose and structured sections (when to use, args, returns, raises). Could be slightly shorter but no wasted sentences.

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 simple tool (1 param, clear annotations, output schema empty), description covers purpose, usage, side effects, return value, and errors. No gaps.

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

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

Schema description coverage is 0% per context, yet description merely repeats 'parser_id (required)' without adding meaning beyond schema's own description ('The parser id to delete. Required.'). Minimal value 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 description clearly states 'Delete an AI parser' and specifies it permanently removes the parser and all its versions. It distinguishes from sibling tools like 'ai_parser_update' for modifying fields.

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

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

Explicit 'When to use' and 'When NOT to use' sections guide agent: use for removing unwanted parsers, avoid for field changes (use ai_parser_update).

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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds context: returns status values (GENERATING, FINISHED, FAILED), fields, example results, errors, and the need to poll until FINISHED. It also mentions potential ToolError conditions (missing API key, rate limit, failure). This aligns with and enriches the annotations, no contradictions.

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 summary, separate sections for usage, args, returns, and raises. Every sentence adds value without redundancy. It is front-loaded with the primary purpose and polls status information, making it easy 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?

Given the simple parameter set (1 required param), comprehensive annotations (readOnly, idempotent), and presence of an output schema (though not detailed in description), the description covers all necessary aspects: purpose, usage, behavior, errors, and return value type. It is 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?

Context indicates schema description coverage is 0%, meaning the schema lacks parameter descriptions. The description only briefly mentions 'parser_id (required) and optional version' without adding further meaning (e.g., format, constraints, or usage nuances). It does not compensate adequately for the missing schema descriptions, leaving the agent underinformed.

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 gets an AI parser's details and generation status. It explicitly distinguishes from siblings by mentioning polling after create/update and inspecting fields before parsing, and by saying not to use for extracting data (use ai_parser_parse_url). The verb 'Get' and resource are 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 has dedicated 'When to use' and 'When NOT to use' sections. It specifies polling after create/update, inspecting fields before parsing, and explicitly warns against using for data extraction, pointing to ai_parser_parse_url as the alternative. This provides excellent guidance.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true. Description adds transparency about error conditions (missing API key, rate limit, request failure) and return type (JSON array). No contradictions.

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?

Description is well-structured with clear sections, no redundant sentences. Every sentence serves a purpose (what it does, when to use, returns, raises).

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

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

Given zero parameters, rich annotations, and an output schema, the description is complete: it covers purpose, usage, return format, and errors. No gaps.

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

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

Tool has no parameters; schema description coverage is 100% trivially. Description adds value by explaining the return format and behavior, meeting the baseline of 4 for zero-parameter tools.

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

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

The description clearly states that the tool lists AI parsers on the account and specifies the returned fields (id, name, status, version, generation time). It explicitly distinguishes from the sibling tool 'ai_parser_get_details' which retrieves full details of one parser.

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

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

Provides explicit 'When to use' (discovering parsers before reuse) and 'When NOT to use' (getting one parser's full details) with a specific alternative named ('ai_parser_get_details').

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds beyond these: cost (1 credit per call) and specific error conditions (missing API key, rate limit, request failure). This extra context is valuable and consistent with annotations.

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

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

The description is well-organized into clear sections: main purpose, usage guidelines, arguments, returns, and raises. It is concise with no redundant sentences and front-loads the essential information.

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

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

Given the tool's complexity and the presence of an output schema, the description covers all necessary context: prerequisites (parser must be FINISHED), cost, error conditions, and return format ('parser', 'version', 'result'). It leaves no critical gaps for an agent to misuse 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?

The schema already describes each parameter (parser_id, url, version). The description's 'Args' section restates the required fields but adds no new semantic information beyond the schema. Since schema coverage is effectively high and the description doesn't compensate further, a baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Parse a URL' with an existing AI parser, returning structured data. It distinguishes from sibling tools by explicitly mentioning alternatives for not-ready parsers ('ai_parser_create', 'ai_parser_get_details') and one-off fetches ('scrape'), making it distinct from other scraping/parser tools.

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

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

The description provides explicit 'When to use' and 'When NOT to use' sections, including specific alternatives and conditions. It tells the agent to use this tool only when the parser is 'FINISHED' and directs other cases to appropriate siblings, offering clear decision 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?

Discloses that add/modify fields trigger asynchronous regeneration (poll 'ai_parser_get_details') while rename/remove apply immediately. No contradiction with annotations (readOnlyHint=false, destructiveHint=false). This adds crucial context beyond 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?

Well-structured with clear sections (description, when to use/not, args, returns, raises). Every sentence serves a purpose; no fluff. Front-loaded with the core action.

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

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

Covers all essential aspects: purpose, usage context, parameter summary, return value, and error conditions. Output schema exists, so return details are not required. Raises section addresses common failures. Complete for a moderately complex 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?

Despite the input schema containing detailed descriptions for each parameter, the tool's description summarizes the parameters in a concise 'Args' section. It adds value by grouping parameters and clarifying optionality, though the schema already covers individual semantics well.

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

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

Description explicitly states 'Edit an AI parser's fields, creating a new version.' It distinguishes from sibling 'ai_parser_create' by specifying when to use each. Additionally, it enumerates specific operations (add, modify, rename, remove), leaving no 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?

Includes a dedicated 'When to use' and 'When NOT to use' section, directing agents to use 'ai_parser_create' for new parsers. This clearly defines the tool's domain and prevents misuse.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds details about return format (JSON/CSV) and error conditions (API key, rate limit, request failure), enhancing transparency.

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

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

Well-structured with sections for purpose, usage, arguments, returns, and raises. No redundant sentences. 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?

Covers usage context, alternatives, and error handling. With an output schema, return details are sufficient. Some aspects like pagination or offer count are absent but not critical.

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?

Description lists the parameters but relies on schema descriptions (which are present) for details. It adds minimal value beyond summarizing optional filters.

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

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

The description clearly states the tool retrieves seller offers for an Amazon ASIN, listing specific fields. It distinguishes from siblings amazon_product and amazon_search.

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

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

Explicit 'When to use' and 'When NOT to use' sections with named alternative tools for product details and search.

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

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

Annotations already indicate a safe, read-only operation. The description adds behavioral context such as the parsed nature of the output, error conditions (ToolError for rate limits, missing API key), and the output format, without contradicting annotations.

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

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

The description is concise, well-organized into sections, and front-loads the core action. Every sentence serves a purpose, with no wasted words.

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

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

Given the tool has a comprehensive output schema and nested parameters, the description provides full context: use cases, alternatives, error handling, and supported formats, leaving no significant gaps.

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

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

The description lists parameter names but does not add substantial meaning beyond the detailed input schema, which already describes each field. Schema coverage is effectively high, warranting a baseline of 3.

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

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

The description clearly states the tool retrieves parsed details for a single Amazon product by ASIN, listing specific data fields. It distinguishes itself from siblings like 'amazon_search' and 'amazon_offers' with explicit usage guidance.

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 includes 'When to use' and 'When NOT to use' sections with concrete scenarios and alternative tool recommendations, providing strong decision support for the agent.

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?

Discloses return structure (product name, price, etc.), pagination, and error conditions (missing API key, rate limit, request failure). No contradiction with annotations which declare readOnlyHint, idempotentHint, not destructive.

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?

Well-structured with sections, front-loaded with purpose, and every sentence adds value. 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?

Covers purpose, usage, return format, errors, and parameter list. Given the richness of annotations and output schema, the description is complete and aids 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?

Description only lists parameter names without adding meaning beyond what the schema already provides. Schema coverage is 0%, but the description does not compensate; it merely repeats parameter names in the Args section.

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

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

Clearly states the tool retrieves parsed Amazon search results for a query. Distinguishes from siblings by mentioning that if you already have an ASIN, use 'amazon_product' or 'amazon_offers'.

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

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

Explicit 'When to use' and 'When NOT to use' sections. Specifies discovering products and price research as use cases, and explicitly names alternative tools for known ASINs.

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

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

Annotations already mark destructiveHint and idempotentHint as true. The description adds important context: 'Irreversibly cancels', 'removes it', and 'there is no resume', which goes beyond the annotations and informs the agent of the permanent nature of the action.

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-organized with clear sections (overview, when to use, when not to use, args, returns, raises). It is concise, with no unnecessary words, and every sentence serves a 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?

Given the tool's simplicity, the description covers the purpose, usage conditions, parameters, return type, and possible errors. With annotations and schema, it provides complete context for an agent to use the tool correctly.

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

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

The only parameter, job_id, is described as 'the id returned by crawler_job_start', which adds meaning beyond the schema's description. The description also mentions it is required, and the parameter structure 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?

The description clearly states the tool cancels and deletes a ScraperAPI crawl job. It specifies the verb 'Cancel and delete' and the resource 'crawl job', and distinguishes it from sibling tools like crawler_job_start and crawler_job_status.

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

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

The description explicitly includes 'When to use' and 'When NOT to use' sections, advising to use it for stopping a crawl and not to use it for pausing because the action is irreversible. This provides clear guidance on when to choose this tool over alternatives.

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

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

The description adds substantial behavioral context beyond annotations: asynchronous execution, immediate return with job id, background crawl, progress tracking methods, bounds via max_depth or crawl_budget, and error conditions (ToolError). No contradictions with annotations.

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

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

Well-organized with paragraphs, bullet points, and clear sections. Every sentence adds value without redundancy.

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

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

The description covers all necessary aspects: purpose, async behavior, tracking, parameters, error handling, and return format. With an output schema existing, the description doesn't need to detail return values 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?

While the schema has detailed descriptions for parameters, the tool description provides high-level guidance on required and optional parameters (e.g., start_url and url_regexp_include required, bounds alternatives).

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 starts a ScraperAPI crawl job from a starting URL, explaining it submits an asynchronous crawl that follows links matching a regex. It distinguishes from siblings like 'scrape' and SDE tools.

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

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

Explicit 'When to use' and 'When NOT to use' sections are provided, naming alternative tools ('scrape' for single URLs, SDE tools for structured lookups) and explaining how to track progress via polling or webhook.

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

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

Annotations already provide readOnlyHint, idempotentHint, openWorldHint, no destructiveHint. The description adds concrete details: returns JSON with counts, raises ToolError for missing API key, rate limit, or request failure. Does not contradict 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?

Well-structured with clear sections (main, when to use, when not, args, returns, raises). Slightly verbose but all sentences add value. Front-loaded with 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?

Given the simple parameter set and rich annotations, the description covers return format, error conditions, relationship to other tools, and expected usage pattern. No gaps.

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

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

Only one parameter (params.job_id) whose description in the description reinforces the schema: 'job_id (required) — the id returned by crawler_job_start.' The schema itself has a description, but the description adds context by linking to the previous tool.

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

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

The description clearly states 'Get the status of a ScraperAPI crawl job' and specifies it returns counts of pages (done, failed, active). It distinguishes from siblings like crawler_job_start and crawler_job_delete by its polling purpose.

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

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

Explicit 'When to use' and 'When NOT to use' sections: use for tracking progress/detecting completion, not for retrieving page contents (which go to callback_url). Mentions polling after crawler_job_start.

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

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

Beyond the annotations (which already indicate read-only, idempotent behavior), the description adds that the tool returns JSON or CSV output, mentions possible error conditions (missing API key, rate limit), and outlines the return structure. No contradiction with annotations.

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

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

The description is well-structured with a clear opening sentence, bulleted usage guidelines, and organized Args/Returns/Raises sections. Every sentence adds value, and the most critical information 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?

Given the annotations (readOnly, idempotent, etc.) and the presence of an output schema, the description fully covers return format, error cases, and usage scenarios. No gaps identified.

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 summarizes the parameters (required product_id, optional tld, country_code, output_format), but the input schema already provides detailed descriptions for each property. The description adds marginal additional 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 explicitly states the action ('Retrieve parsed details') and the resource ('single eBay listing by item ID'). It clearly distinguishes from sibling 'ebay_search' by specifying that this tool requires an item ID, not 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?

Includes dedicated 'When to use' and 'When NOT to use' sections, explicitly directing agents to use 'ebay_search' for keyword-only queries. This provides clear decision guidance.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful context about return formats (JSON/CSV) and potential errors (missing API key, rate limit, request failure). While it doesn't contradict annotations, it could have mentioned the pagination limit or rate limiting details more explicitly, but overall it provides adequate additional transparency.

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

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

The description is well-structured with clear sections: a summary sentence, bullet points for when to use/not use, a compact parameter list, and explicit return/error sections. It is concise with no wasted words, and the most important information (purpose and usage) 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?

The description covers all necessary contextual information: the tool returns structured data with specified fields, supports pagination and filtering, handles errors, and provides output format options. Since there is an output schema (mentioned in context), the description does not need to explain return values in detail. It is complete enough for an agent to understand the tool's behavior and constraints.

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?

Although the schema has detailed descriptions for each property, the tool description summarizes all parameters in the 'Args' section, explaining their purpose and constraints. It covers all 11 parameters (query required, optional page, items_per_page, etc.) and adds context like the output_format default. Given that schema description coverage is 0% (per context, likely referring to the top-level 'params' description), the description fully compensates by providing complete parameter documentation.

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

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

The description clearly states the tool retrieves parsed eBay search results for a query, listing the returned fields (title, price, condition, etc.). It explicitly distinguishes from the sibling tool 'ebay_product' by specifying when not to use it (when you have an item ID), making the purpose very 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 provides explicit guidance on when to use the tool (e.g., discovering listings, price research) and when not to use it (already have an item ID, with a direct alternative: use 'ebay_product'). This fully satisfies the usage guidelines dimension.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value by detailing return content, error conditions (ToolError for missing key, rate limit, request failure), and output formats. It is fully transparent and consistent with annotations.

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

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

The description is well-structured with clear sections and front-loaded purpose. Every sentence adds value, there is no fluff, and it is appropriately sized for the tool's complexity.

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 one parameter (nested object), comprehensive annotations, and an output schema, the description is complete. It covers usage context, return values, and error handling, leaving no gaps.

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

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

The input schema provides detailed descriptions for all parameters, so baseline is 3. The description lists the parameter groups but adds minimal extra meaning beyond what the schema already offers.

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

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

The description clearly states the tool retrieves parsed Google Jobs listings for a query. It specifies the verb (Retrieve) and resource (parsed Google Jobs listings). It distinguishes from siblings like google_search and google_news by explicitly stating when NOT to use this tool and suggesting 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 has explicit 'When to use' and 'When NOT to use' sections, providing clear context for usage. It guides the agent to use this tool for job aggregations and labor-market research, and to avoid it for general web results, directing to alternative tools.

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

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

Annotations already indicate read-only, idempotent, non-destructive. Description adds context: returns parsed structured results, can raise ToolError for missing API key or rate limits, and mentions output format options.

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?

Well-structured with sections, front-loaded with main purpose, but could be slightly more concise. Every sentence contributes meaning.

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

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

Covers usage, return format, error cases, and optional params. Output schema exists, so return values not needed. Annotations cover safety. Fairly complete for a search 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 has low description coverage (0% per context), but description lists required params (query, latitude, longitude) and mentions optional ones (zoom, tld, etc.) without detail. Partially compensates.

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

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

The description clearly states the tool retrieves parsed Google Maps place/business results, with a specific verb and resource. It distinguishes from siblings like google_search by noting it's for local results, not non-local web results.

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

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

Explicit 'When to use' and 'When NOT to use' sections with examples (e.g., 'coffee shops in Austin') and alternatives (google_search for non-local results, not for directions).

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false. The description adds behavioral context: returns structured news, raises ToolError on API/rate-limit issues. No contradictions. Adds value beyond annotations.

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

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

The description is well-structured with sections (when to use, args, returns, raises) and front-loads purpose. A bit verbose but acceptable; every section earns its place.

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

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

Given the moderate complexity (many parameters, output schema exists), the description covers purpose, usage, parameters, return format (JSON/CSV), and error conditions. Output schema covers return values, so description is 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 high (each parameter in GoogleNewsParams has a description). The tool description summarizes parameters briefly but does not add significant new meaning. Baseline 3 is appropriate.

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

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

The description clearly states 'Retrieve parsed Google News results for a query' and specifies the returned fields (title, source, link, timestamp, snippet). It distinguishes from sibling tools like 'google_search' and 'scrape'.

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

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

The description explicitly lists when to use (monitoring news, time-bounded scans) and when NOT to use (general web, reading full articles) with alternatives named. This provides excellent 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?

Describes returns (JSON/CSV parsed), error conditions (missing API key, rate limits), and reinforces readOnlyHint=true by framing as retrieval. No contradiction with annotations.

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

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

Well-organized into sections: main purpose, usage guidelines, args, returns, raises. Every sentence earns its place; no redundancy.

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

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

Covers purpose, usage, parameters, return format, and errors. With output schema and annotations, the description provides all necessary context for an agent.

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 high (nested params have descriptions). The description adds value by grouping optional parameters into categories (localization, pagination, date filters) and noting required query, though detailed semantics are already in the schema.

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

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

The description clearly states it retrieves parsed Google Search results, lists specific components (organic results, ads, knowledge panels), and distinguishes from sibling tools by referencing dedicated tools for News, Jobs, Shopping, and Maps.

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

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

Explicit 'When to use' and 'When NOT to use' sections with concrete examples: use for SERP data, SEO, rank tracking; not for specific URL scraping or other Google verticals. Includes alternatives like 'scrape' and dedicated 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 already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering safety and behavior. The description adds context about error conditions (missing API key, rate limit, request failure) and the output format (JSON/CSV). It does not fully detail pagination behavior beyond param hints, but overall it supplements the annotations well without contradiction.

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

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

The description is concise with three paragraphs, a returns clause, and a raises clause. It is front-loaded with the core purpose and structured with clear sections (when to use, when not to use, args, returns). No extraneous information.

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

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

Given the tool's complexity (shopping search with multiple siblings), the description fully covers its role, distinguishes it from alternatives, explains typical use cases, and notes error conditions. It references an output schema, so no further detail on return values is needed. The description is self-contained for an AI agent to decide when and how to invoke it.

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

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

Schema description coverage is 0% (the description does not repeat parameter details), but the schema itself has detailed descriptions for each parameter. The tool description refers to params by category (localization, pagination, etc.), which adds organizational value. Since the schema already provides full parameter semantics, the description's summary is sufficient and adds clarity.

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 ('Retrieve parsed Google Shopping product results') and clearly identifies the resource ('for a query'). It lists the structured fields returned (product title, price, merchant, rating, link) and explicitly distinguishes from sibling marketplace tools (Amazon, Walmart, eBay) and general web search, making the purpose unambiguous.

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

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

The description includes explicit 'When to use' (price comparison, market research) and 'When NOT to use' sections, naming specific alternatives like amazon_search, walmart_search, and google_search. This provides clear decision criteria for the agent.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds context about return format (JSON/CSV) and error conditions (missing API key, rate limit, request failure), which complements annotations without contradiction.

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 clear sections, concise sentences, and no redundant information. Every sentence serves a purpose, making it easy for an AI 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?

Given the tool's complexity (1 parameter with sub-properties), rich annotations, and presence of an output schema, the description is complete. It covers purpose, usage, parameters, return type, and error cases, leaving no gaps for the AI agent.

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?

Despite 'Schema description coverage: 0%' in context, the actual schema input shows descriptions for each parameter. The description adds value by summarizing the required URL and optional parameters (tld, country_code, output_format) and explaining their purposes, going beyond the schema's individual descriptions.

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

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

The description clearly states 'Retrieve parsed Redfin real-estate agent profile data' and lists the specific data returned (name, contact, brokerage, ratings, transactions). It also explicitly distinguishes from property/search tools in the 'When NOT to use' section, differentiating it from sibling tools like redfin_for_sale and redfin_search.

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

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

The description provides explicit 'When to use' (extracting agent profile, lead building) and 'When NOT to use' (property or search data, with reference to other Redfin tools). This gives clear guidance to the AI agent on when to select this tool versus alternatives.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. Description adds error conditions (ToolError for missing API key, rate limit exceeded, request failure). Does not contradict annotations. No further behavioral context needed.

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?

Description is well-structured with clear sections (purpose, when to use/not use, args, returns, raises). Front-loaded with main action. Every sentence adds value without redundancy.

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

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

Tool is a data retrieval endpoint with output schema and annotations. Description covers use cases, parameter summary, and error raising. Minor gap: rate limit details could be more explicit, but overall 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 descriptions cover all parameters (100% coverage), so baseline is 3. Description merely summarizes the parameters (url required, others optional) without adding new 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?

Description clearly states 'Retrieve parsed Redfin listing data for a rental property' with specific verb and resource. Lists returned fields and distinguishes from siblings by explicitly naming redfin_for_sale, redfin_search, and redfin_agent.

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

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

Includes explicit 'When to use' and 'When NOT to use' sections with specific use cases and alternative tool names, providing excellent guidance for 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds value by noting error conditions (missing API key, rate limit, request failure) and the output format, but does not mention caching or internal state changes, which are already covered by idempotency.

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, structured with clear sections (When to use, When NOT to use, Args, Returns, Raises). Every sentence adds value, and there is no redundancy or 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?

Given the existence of an output schema, the description adequately covers the return value. The tool is simple (one required param) and annotations cover safety. The description provides all necessary behavioral context beyond structured fields.

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

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

All parameters are well-described in the input schema (100% coverage). The description only lists the parameters without adding new meaning, so it meets the baseline of 3. It does not provide extra context beyond the schema.

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

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

The description uses a specific verb 'Retrieve' and identifies the resource as 'parsed Redfin listing data for a home for sale'. It also lists the data fields (price, beds/baths, etc.) and distinguishes from siblings redfin_for_rent, redfin_search, and redfin_agent.

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

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

Explicit 'When to use' and 'When NOT to use' sections provide clear guidance, naming alternative tools for rentals, search results, and agent profiles. The description helps the agent decide when to invoke this tool over siblings.

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 (readOnlyHint=true, idempotentHint=true, destructiveHint=false) already indicate safety. Description adds return format details and potential errors (API key, rate limit, request failure), which are consistent with annotations.

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

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

Description is well-organized with clear sections, no redundancy, and every sentence adds value. Efficient use of space.

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 (single parameter with nested sub-params, output schema exists, annotations present), the description covers purpose, usage, parameters, return type, and errors comprehensively.

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

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

Schema description coverage is 0%, so description must compensate. It lists all four parameters (url, tld, country_code, output_format) and explains url is required and must be a search-results URL, adding 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 clearly states the verb 'Retrieve parsed Redfin search results' and specifies the resource 'for a search-results URL'. It distinguishes from sibling tools like redfin_for_sale and redfin_for_rent by explicitly noting when not to use 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?

Includes explicit 'When to use' and 'When NOT to use' sections, with specific mention of alternative tools (redfin_for_sale, redfin_for_rent). Provides clear context for appropriate 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?

Adds context about pagination, error conditions (ToolError), and output format options beyond the annotations which already indicate idempotent and non-destructive behavior. Does not contradict 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?

Well-structured with headings, concise yet informative. Every sentence adds 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?

Output schema exists; description mentions return formats and errors. With rich annotations and sibling distinctions, coverage is good. Missing details on pagination behavior (e.g., max pages) but overall complete.

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

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

Schema coverage is 0%, so description must compensate. It lists the parameters but only briefly repeats the schema's own descriptions without adding significant detail. Adequate but not exceptional.

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

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

Description clearly states it browses parsed products within a Walmart category by ID, with pagination. Distinguishes from 'walmart_search' for free-text discovery.

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

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

Explicit 'When to use' and 'When NOT to use' sections, clearly pointing to walmart_search as alternative.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds information on error conditions (API key, rate limit, request failure) and return format, but does not contradict 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?

Well-structured with clear sections, front-loaded purpose, and no wasted words. Every sentence adds 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?

Covers purpose, usage guidelines, parameters, return type, and error conditions. Lacks explicit output schema details, but the listed data fields provide adequate context for a simple lookup 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?

The description summarizes parameters (product_id required, optional tld, country_code, output_format) but the schema already contains full descriptions. The description adds little new 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 clearly states the tool retrieves parsed details for a single Walmart product by ID, explicitly distinguishes from siblings like walmart_search and walmart_review, and lists the data fields returned.

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?

Includes explicit 'When to use' and 'When NOT to use' sections with specific alternative tools (walmart_search, walmart_review), providing clear guidance on when to invoke this tool.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds valuable context: returns structured reviews with specific fields, supports pagination and filters, and raises ToolError for API/rate-limit issues. No contradictions with annotations.

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

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

Well-structured with sections, bullet points, and front-loaded purpose. Every sentence contributes value, though the 'Args:' section partly duplicates schema info. Overall efficient and readable.

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 annotations and schema richness, the description adequately covers return format (JSON/CSV with fields), use cases, and error handling. No output schema is provided, but the description explains return structure sufficiently for an agent to understand what to expect.

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

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

Input schema has detailed descriptions for all parameters (100% coverage), so baseline is 3. The description lists the parameters but doesn't add much meaning beyond what the schema already provides; it does clarify that product_id is required and that optional params enable pagination/sorting/filters.

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

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

The description clearly states the tool retrieves parsed customer reviews for a Walmart product by product ID. It specifies the verb (retrieve), resource (reviews), and unique identifier. The 'When NOT to use' section distinguishes it from siblings like walmart_product and walmart_search.

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

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

Explicit 'When to use' and 'When NOT to use' sections are provided, with clear context for sentiment analysis or review mining and alternatives for product details or search. This gives direct guidance on 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds value by specifying error conditions (missing API key, rate limit, request failure) and the return format (JSON or CSV), which goes beyond the annotations.

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

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

The description is concise yet comprehensive, with clear sections for usage guidance, args, returns, and raises. It is front-loaded with the core purpose and economically uses sentences.

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 rich annotations and the presence of an output schema, the description covers all necessary aspects: purpose, usage constraints, parameter hints, error handling, and return format. It is sufficient 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?

Schema description coverage is high; each parameter in the input schema has a detailed description. The tool description only lists parameter names briefly without adding deeper meaning. Baseline 3 is appropriate as the schema handles parameter semantics well.

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 Walmart product search results for a query, listing specific fields returned (product name, price, rating, etc.) and pagination. It distinguishes itself from siblings by explicitly mentioning when not to use it and naming alternatives like walmart_product and walmart_review.

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

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

Provides explicit when-to-use scenarios (discovering products, price research, catalog building) and when-not-to-use with named alternative tools (walmart_product, walmart_review). This guidance is clear and actionable.

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