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

No annotations are provided, so the description carries full burden. It describes the operation as a search returning list data, but does not mention read-only nature, authentication, or potential side effects. Adequate but not detailed.

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

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

The description is front-loaded with the title and elaborates efficiently. A minor redundancy is the repeated title, but overall it is well-structured and concise.

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

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

Given no output schema, the description lists most returned fields but lacks details on pagination mechanics, date format expectations, and error handling. It covers use cases but could be more complete for a complex 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 coverage is 100%, so the base score is 3. The description groups parameters and adds context but does not significantly enhance meaning beyond what the schema already provides.

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

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

The description clearly states the verb 'Searches' and the resource 'Airbnb listings', enumerates input parameters and output fields, and distinguishes from sibling tools by being specific to Airbnb listings 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 clear use cases like travel planning and market analysis, but does not explicitly mention when not to use or suggest alternative tools for specific needs like property 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?

With no annotations, the description carries the full burden. The tool name 'Get' implies read-only, but the description does not confirm it is non-destructive, nor does it mention rate limits, authentication needs, or what happens on failure. This lack of explicit behavioral disclosure is a significant gap for a data-fetching 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 moderately concise, starting with the action and listing the return fields efficiently. It could be slightly tighter, but it is well-structured and avoids unnecessary words, earning a score of 4.

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 complexity of the tool (returns a rich set of property details) and no output schema, the description comprehensively lists the data fields. However, it omits potential error conditions (e.g., invalid URL) and behavioral notes, which would enhance completeness. Overall, it covers the main use cases and outputs well.

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 100% coverage (one parameter, 'url', with a clear description). The description adds context about using the URL to fetch the property page but does not provide additional semantic detail beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool fetches full Airbnb property details by listing URL, lists specific return fields (title, description, location, coordinates, price, fees, ratings, etc.), and distinguishes it from the sibling 'listing-search' endpoint by emphasizing deep-dive enrichment. This provides a specific verb+resource+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?

The description explicitly recommends use for travel-planning agents, deep-dive rate research, photo/amenity enrichment of listings from the listing-search endpoint, and compliance audits. It implies appropriate contexts but does not explicitly state when not to use it or mention alternatives beyond the listing-search endpoint.

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 fully carries the burden of behavioral disclosure. It mentions that otherSellers=true triggers extra data extraction and that deliveryZip/shippingLocation affect pricing. It does not cover rate limits or auth, but for a read-only product lookup, this is adequate.

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 moderately sized with a clear title and structured sentences. It front-loads the core purpose and then lists return fields and use cases. A bit verbose in listing all return fields, but still efficient overall.

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 lack of an output schema, the description provides a comprehensive list of return fields (title, brand, price, availability, etc.) and covers behavior for optional parameters (otherSellers, delivery zip/location). It is complete for an agent to understand what the tool does and what to expect.

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

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

All 6 parameters are described in the schema (100% coverage). The description adds context beyond the schema: it explains the role of otherSellers (triggering other sellers block) and notes that deliveryZip and shippingLocation enable delivery-zone-aware pricing. This adds meaningful 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 explicitly states it fetches a single Amazon product page by ASIN on a chosen domain, and lists the extensive data returned. It clearly distinguishes itself from sibling tools like search, reviews, and seller details.

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 enumerates specific use cases such as product research, price/stock monitoring, catalog enrichment, listing QA, Buy Box tracking, and cross-locale analysis. It does not explicitly state when not to use or mention alternatives, but the context is clear enough for an agent to infer appropriate 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?

No annotations are provided, and the description only mentions 'Paginated fetch' without detailing rate limits, authentication needs, or error behavior. It does not disclose what happens on API limits or missing data, leaving gaps for an agent.

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

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

The description is two sentences: a clear introductory line and a concise second sentence that packs the features and use cases. No redundant text, but could be more structured with bullet points for 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 lists return fields (title, body, rating, etc.) which partially compensates for missing output schema. However, given the tool's complexity (10 parameters, pagination), it lacks details on pagination limits, default page size, or error scenarios.

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

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

Schema coverage is 100% with parameter descriptions, so the baseline is 3. The description enumerates filter options (star rating, reviewer type, etc.) but does not add meaning beyond the schema. For instance, 'positive' and 'critical' stars are not explained.

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 Amazon Product Reviews' and specifies the action (paginated fetch) and resource (Amazon ASIN). It distinguishes itself from sibling tools by focusing specifically on product reviews.

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 lists several use cases (voice-of-customer analysis, sentiment extraction, etc.) but does not explicitly state when NOT to use this tool or compare it to siblings like getProductDetails or search. It gives context but lacks 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 transparently covers the read-only nature, pagination, supported sort orders, delivery location scoping, and the structure of returned data. However, it omits details on rate limits, data freshness, or authentication requirements.

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, covering functionality, parameters, returns, and use cases in a single paragraph. It is front-loaded and each sentence adds value, though it could be structured with bullet points for clarity.

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 no output schema, the description provides a detailed list of return fields and mentions related suggestions and facets. It is sufficient for understanding the tool’s role in product research and price comparison, though it lacks explicit mention of the response format.

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

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

Schema coverage is 100% and the description adds little beyond listing parameters like 'domain' and 'sortBy'. It contextualizes their role in filtering and sorting but does not significantly extend the schema 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 the tool performs a keyword search on Amazon domains with pagination, delivery scoping, and sort options. It enumerates return fields (ASIN, title, price, etc.) and lists concrete use cases like SERP monitoring and competitor discovery, distinguishing it from siblings such as product details or reviews.

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?

Use cases are provided but no explicit guidance on when to use this tool versus alternatives. It does not mention when not to use it or contrast with sibling tools like product details or seller details, leaving the agent to infer based on return fields.

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 convey behavioral traits. It explicitly states the tool 'Fetches the public storefront profile', confirming it is a read-only operation. It does not mention rate limits or authentication, but the read-only nature is clear.

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

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

The description is two sentences long and efficiently conveys purpose and return data. The first sentence serves as a clear verb+resource statement, and the second provides details and use cases. It is slightly dense but well-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?

Given the absence of an output schema, the description compensates by listing the key data fields returned (business name, ratings, address, etc.). It also covers use cases sufficiently. No missing critical information for a seller details retrieval 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 input schema has 100% coverage with descriptions for all three parameters. The description does not add meaning beyond the schema; it only restates the parameter roles implied by schema's descriptions and enums. 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 it fetches the public storefront profile for an Amazon seller by sellerId on a specified domain and language. It lists the specific data returned (business name, feedback ratings, etc.) and distinguishes this tool from the sibling 'hasdata_amazon_seller_products_getSellerProducts' by focusing on seller profile details rather than their products.

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 lists several use cases (due-diligence, brand protection, etc.) but does not explicitly compare this tool to alternatives like 'getSellerProducts'. Usage context is implied but could be clearer on when not to use it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains that the tool returns paginated results with specific fields and implies read-only behavior. It does not cover rate limits or authentication but provides sufficient transparency for typical use.

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: a title line, a summary sentence, a return fields sentence, and a use case sentence. It is front-loaded and each 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 purpose, return fields, and use cases, but given no output schema, it does not specify the return structure (e.g., array, pagination metadata missing). It also does not explain the optional language parameter. These gaps limit completeness.

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

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

Schema description coverage is 100%, so all parameters already have descriptions in the input schema. The tool description adds no additional parameter-level information beyond implying pagination via 'page' and domain selection. Thus it meets the baseline but does not enhance parameter understanding.

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 provides a paginated listing of products for a given Amazon sellerId on a domain, distinguishing it from siblings like product details, reviews, search, or seller details tools. It specifies the return fields and use cases, 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 lists concrete use cases such as mapping a competitor's assortment, detecting new SKUs, and building watchlists, which imply when to use this tool. However, it does not explicitly state when not to use it or name alternative tools, though context from siblings suggests 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?

Without annotations, the description carries full responsibility. It explains that the tool fetches SERPs, accepts various parameters (geo, market, safesearch, filters, device type, pagination), and returns organic results, related searches, and answer boxes. This provides sufficient behavioral insight without side effects or rate limits.

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

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

The description is concise yet comprehensive, front-loading the core function and then listing capabilities in a structured list-like format. No redundant or vague statements; 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?

Given 11 parameters and no output schema, the description covers all essential aspects: input parameters, return types, and use cases. It even provides example filter syntax. This makes the tool easy to understand and use without additional documentation.

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

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

Schema coverage is 100% with descriptions, but the description adds value by grouping parameters (e.g., 'geo targeting (location/lat/lon)') and explaining their purpose in context. It highlights key constraints like 'count up to 50' and 'first offset' for pagination, which aids understanding 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 'Get Bing Search Results' and details the functionality: fetching SERPs with geo targeting, market, etc. It lists return types (organic results, related searches, answer boxes) and specifies use cases like SEO rank tracking. This distinguishes it from sibling tools focused on other platforms (e.g., Google, Amazon).

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 intended use cases: 'SEO rank tracking, SERP feature monitoring, Bing-specific visibility audits, and training/eval data for search agents.' It provides clear context but does not explicitly state when not to use or mention 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?

No annotations are provided, so the description bears full responsibility for behavioral transparency. It explains the tool fetches details by URL and returns many fields, but it does not disclose error handling, rate limits, or authentication requirements. The behavior is partially transparent.

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 paragraph of four sentences. It front-loads the purpose and immediately lists returns and use cases. The first sentence is slightly redundant with the title 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?

Given the tool has one parameter, no output schema, and no annotations, the description covers the essential information: what it does, what it returns, and why to use it. It is complete enough for a simple fetch operation, though it lacks details on potential errors.

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

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

Schema coverage is 100% with the single 'url' parameter already described as the job vacancy URL. The description repeats this without adding extra semantic nuance, so it meets the baseline for high coverage but does not exceed it.

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 'Fetches' and the resource 'Glassdoor job posting by its vacancy URL'. It lists the specific data returned (title, company, salary, etc.) and outlines use cases, making the tool's purpose distinct from sibling tools like the listing 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?

The description provides explicit use cases such as 'ATS ingestion', 'job aggregators', and 'comp benchmarking', offering clear context for when to use the tool. However, it does not explicitly specify when not to use it or compare it to alternatives like the Glassdoor listings tool.

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

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

With no annotations, the description fully details the return structure (fields like title, company, salary estimate, etc.) and pagination behavior via nextPageToken. It does not mention any destructive actions or auth requirements, but for a GET endpoint this is acceptable.

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 composed of two clear paragraphs: one explaining functionality and one listing use cases. It is efficient without redundancy, though a bit verbose for an experienced user.

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 no output schema and 5 parameters, the description covers the return values (array of jobs with specific fields) and pagination, plus use cases. It lacks details on default sort or domain, but overall it is complete enough for an agent to use correctly.

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

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

The input schema has 100% parameter description coverage, so the description only adds minimal context (like 'searches by keyword and location with sort, domain targeting'). The baseline of 3 is appropriate as the schema already explains each parameter 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 identifies the tool as retrieving GlassDoor job listings, specifying search by keyword and location with optional sort, domain, and pagination. It distinguishes itself from its sibling 'hasdata_glassdoor_job_getJobDetails' by stating it returns listings for downstream scraping.

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 use cases like building job feeds and monitoring trends, and mentions the alternative endpoint for full details. However, it does not explicitly state when not to use this tool (e.g., if full details are needed immediately).

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

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

Without annotations, the description carries the full burden. It mentions pagination (ijn) and scraping behavior, but lacks details on rate limits, authentication, or any side effects. The disclosure is adequate but not exhaustive.

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 concise, three-sentence paragraph that front-loads the core action and follows with capabilities and use cases. It is efficient with no wasteful content.

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

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

Given the complexity (11 parameters, no output schema, no annotations), the description covers the main capabilities, return fields, and use cases. It could elaborate on output structure further, but the provided details are sufficient.

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

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

Schema coverage is 100%, so the schema already documents all parameters thoroughly. The description groups parameters conceptually and lists return fields, adding marginal 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 clearly states the tool 'Get Image Search Results' against Google Images, lists specific filters and pagination, and distinguishes it from sibling Google search tools by focusing on image-specific features and return 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?

The description explicitly enumerates use cases (visual discovery, reverse-image workflows, dataset collection, brand monitoring, etc.) but does not provide when-not-to-use guidance or compare with 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?

No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, rate limits, or authentication requirements. The description focuses on functionality rather than 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 single concise paragraph that efficiently conveys purpose, returned fields, and use cases. No redundant information, though bullet points could improve 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?

For a tool with 5 parameters and no output schema, the description covers the main purpose and return fields but lacks information on output structure, pagination limits, or potential side effects. 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 coverage is 100%, so the schema already describes all parameters. The description adds minimal context by mentioning 'language/country targeting' and 'nextPageToken pagination', but does not enrich parameter 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 lists all Google Maps reviews for a specific contributor by contributorId, distinguishing it from sibling tools like getMapReviews for place reviews.

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 specific use cases like reviewer reputation checks and fake review detection, making it easy to decide when to use this tool. No explicit exclusion of alternatives, but the context is clear.

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

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

No annotations are provided, so the description carries the full burden. It discloses pagination (nextPageToken), filtering by categoryId, and return fields (image URL, thumbnail, etc.). It does not mention rate limits or exact page size, but covers core behavior well.

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, dense paragraph that front-loads the purpose, then details parameters and use cases. Every sentence adds useful information with no redundancy.

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

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

Given the tool's moderate complexity (pagination, filtering), the description covers inputs, outputs, and use cases thoroughly. No output schema exists, but the description lists return fields, making it 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 100%, baseline 3. The description adds value by explaining that dataId and placeId are alternatives, listing categoryId filter values (all, latest, menu, etc.), and specifying returned fields 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 fetches the photo gallery of a Google Maps place using dataId or placeId, and distinguishes from sibling tools like getPlaceDetails or reviews by focusing specifically on photos.

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 use cases such as restaurant-menu extraction and venue visual audits, implicitly guiding when to use this tool over siblings. However, it lacks explicit 'when not to use' statements.

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

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

No annotations provided, so description carries full burden. It describes the tool as fetching data and lists returned fields, implying a read operation. However, it lacks detail on failure cases, rate limits, or authentication requirements.

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

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

Two sentences: first explains the function, second lists fields and use cases. Front-loaded and 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 no output schema, the description lists many return fields, covering key aspects. With many sibling tools, this description is sufficient for an agent to understand and use 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 100% with good descriptions. The description adds a list of return fields but does not significantly enhance parameter understanding 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 fetches full Google Maps place data by placeId with optional domain/language localization, and lists specific use cases. It distinguishes from sibling tools like search and reviews.

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 lists explicit use cases (local SEO audits, POI enrichment, etc.) but does not mention when not to use or compare with other place detail tools. Still provides good 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 fully bears the responsibility. It describes the tool as a paginated fetch and lists return fields, but omits how pagination works (e.g., nextPageToken usage), rate limits, or authentication. This leaves key behavioral details unclear.

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 paragraph that front-loads the purpose and efficiently conveys key information. It could be better structured (e.g., bullet points for return fields), but it is clear and without excessive verbosity.

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

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

The description covers the main purpose, parameters, and return data, which is sufficient for a simple read tool. However, it lacks explanation of pagination mechanics (how to use nextPageToken) and error conditions, leaving some gaps given no output schema.

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

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

The input schema has 100% parameter description coverage, providing basic definitions. The description adds value by explaining sorting options (qualityScore, newestFirst, etc.) and the topic filter, but does not elaborate on parameters beyond what schema already states.

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

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

The description clearly states the tool fetches Google Maps reviews for a place, using dataId or placeId, with sorting, filtering, and language options. It distinguishes itself from sibling tools like 'getMapPhotos' by focusing on reviews, but does not explicitly differentiate from the contributor reviews 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?

The description lists specific use cases (reputation management, sentiment mining, etc.), providing clear context for when to use the tool. However, it does not mention when not to use it or compare with alternative tools (e.g., contributor reviews).

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

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

The description explains the return format (local pack list) and key parameters like pagination and GPS coordinates. However, with no annotations provided, it does not disclose any side effects, rate limits, or authentication needs, leaving some behavioral ambiguity.

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 concise paragraph with a clear opening line, followed by parameter explanations and use case examples. 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 the return fields, pagination via 'start', and integration with sibling tools. However, it omits details on result limits, error conditions, and the interaction between zoom level and location, which would be helpful for a tool with 6 parameters.

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

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

Schema coverage is 100%, so baseline is 3. The description adds marginal value by hinting at the relationship between 'll' and 'start' and the format of 'll'. However, the schema already describes each parameter adequately.

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 'Runs a Google Maps search by keyword plus optional GPS coordinates' and lists the return fields. It clearly identifies the tool's purpose as a search tool for local business data, distinct from sibling tools like place details or reviews.

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 lists concrete use cases (local lead generation, competitor density mapping) and mentions feeding results into other endpoints like Maps Place, Reviews, or Photos. While not explicitly stating when to avoid this tool, it provides strong contextual 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 provided, the description carries the full burden. It details the return components (conversational response, cited sources, subtopics, follow-ups, continuation token) and implies a read-only, AI-powered search, which is adequate 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 a single long paragraph that lists many use cases and examples, making it somewhat verbose and less concise. Not all sentences are essential; some redundancy exists between the use case list and examples.

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

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

While the description covers the main purpose and return components, it lacks detailed parameter explanations (e.g., location, continuable) and does not compensate for the missing output schema. For a complex tool with 7 parameters and no output schema, more completeness is expected.

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

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

The input schema covers 100% of parameters with descriptions, meeting the baseline for schema coverage. The description adds no extra parameter meaning beyond the schema, only mentioning the search term in examples. Thus, it does not improve parameter understanding beyond what the schema already provides.

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

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

The description clearly states the tool gets AI Mode SERP results from Google Search, listing the components returned. However, it does not differentiate from sibling tools like 'hasdata_google_serp_ai_overview_getAiOverviewResponse' or 'hasdata_google_serp_serp_getSearchResults', which may cause 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 provides extensive use cases and example queries, giving clear context for when to use the tool. However, it does not specify when not to use it or mention alternative tools for similar tasks.

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 reveals that the tool fetches lazy-loaded content via a token valid for 4 minutes. It also outlines returned data (AI answer text, source URLs, subtopic sections). This is good behavioral context for a read-only follow-up tool.

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

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

The description is concise with about 4 sentences, no fluff. Front-loaded with core purpose, then details and use cases. 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?

Given the single parameter and no output schema, the description explains the return type and workflow integration. It is complete enough for an agent to use the tool correctly, though the exact response structure is not detailed.

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

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

Schema coverage is 100% and the description adds context about the parameter (token from `aiOverview` block, 4-minute validity). It clarifies the token's source and purpose beyond the schema description.

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 AI Overview Results' and explains it fetches the lazy-loaded AI Overview block via a pageToken from the Google SERP API. It distinguishes from siblings by specifying it is a follow-up call for AI citations and sourcing.

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

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

Explicitly says 'Use as a follow-up call to Google SERP' and gives concrete use cases (SEO, fact-checking, LLM retrieval). It does not state when not to use or provide alternatives, but the context is clear.

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

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

No annotations provided, so description must cover behavior. It mentions scraping, filters, targeting, pagination, and return fields, but omits details on rate limits, authentication, or potential blocking. Adequate 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?

Mostly concise with relevant information, but the first sentence duplicates the title. The description is front-loaded with clear action and then detailed features. Slight redundancy prevents a perfect score.

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 no output schema, the description enumerates return fields (title, date, venue, links, etc.) and covers key features. Missing error handling or limits, but sufficient for a scraping tool with 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 covers all parameters well. Description adds value by summarizing date filter options and virtual-event toggle, and clarifying the use of location/uule. Though schema is detailed, the description provides useful contextual grouping.

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 scrapes Google Events results with specific filters and returns structured event data. It is unique among siblings as no other tool targets events, so differentiation is implicit.

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

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

Explicitly lists use cases such as event-discovery chatbots, local aggregators, calendar sync, competitive monitoring, and pulling upcoming shows/conferences. Provides clear context without needing 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 moreStores returns up to 13 merchants instead of 3-5, and lists output fields (offers, specs, images, ratings, nextPageToken). It does not cover rate limits or auth, but for a read tool, this is adequate.

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

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

The description is a single well-structured paragraph that front-loads the purpose. It is not overly verbose, though it could be slightly more concise.

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

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

Given no output schema, the description explains the return values (multi-store offers, specs, images, ratings, nextPageToken). It covers what the tool does, its parameters, and typical use cases, making it complete for the 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 coverage is 100%, so baseline is 3. The description adds value by explaining that moreStores fetches up to 13 merchants and nextPageToken paginates results, which is beyond the schema 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 the tool retrieves immersive product information from Google Shopping, using a specific verb 'Get' and identifying the resource. It distinguishes itself from sibling tools by specifying it expands the immersive pop-up, not general search or product 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?

The description lists use cases like price-comparison bots and merchant discovery, and explains when to use optional parameters. However, it does not explicitly state when to avoid this tool in favor of siblings, so it lacks exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses return fields (title, snippet, publisher, etc.) and the concept of token-based navigation. It does not mention read-only nature, but that is implied by 'get'. The description adds value beyond the schema by explaining mutual exclusivity of tokens.

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

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

The description is a single, well-organized paragraph: first sentence states purpose, second explains inputs/returns, third lists use cases. No redundant or irrelevant phrases. 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 tool with 8 parameters, 100% schema coverage, no output schema, and no annotations, the description covers the key aspects: input types, return fields, token relationships, and use cases. It could mention pagination or error handling, but it is sufficient for an agent to use effectively.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by grouping tokens, explaining their mutual exclusivity (e.g., 'q' not allowed with tokens), and detailing the sort option with storyToken. This goes beyond the individual parameter descriptions.

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

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

The description clearly states 'Retrieves Google News results' and lists distinct input methods (query, tokens). It differentiates from sibling tools like general web search by focusing on news and specifying token-based navigation for topics and publishers.

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 use cases: 'news monitoring, brand/PR tracking, topical aggregators, publisher-specific feeds, and drilling into full story coverage.' While it does not directly mention when not to use it, the sibling context (e.g., general search tools) implies the distinction.

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 the tool returns various fields based on searchType, but does not discuss side effects, data freshness, rate limits, or authorization requirements. The read-only nature is implied but 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 a single efficient paragraph of five sentences, front-loading the main action, and every sentence adds value without redundancy. It is well-structured and easy to parse.

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 (9 parameters, no output schema, no annotations), the description covers the main purpose, key parameters, return fields, and use cases. It misses some details like the effect of location/domain parameters and pagination, but the schema descriptions handle those. Suitable for most agents.

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

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

Schema coverage is 100%, baseline 3. The description adds value by explaining how searchType and filter parameters affect the output, and lists return fields, compensating for the lack of output schema. This provides meaningful context beyond the parameter descriptions.

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

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

The description clearly states it pulls detailed product data from Google Shopping by productId, listing specific fields and searchTypes. It distinguishes from sibling tools like shopping search results which are for queries, not specific product 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?

The description implies use when you have a productId and need detailed product info, but it does not explicitly state when to use it versus alternatives like shopping search or immersive product, nor does it provide 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?

No annotations are provided, so the description carries full burden. It discloses that the tool returns organic results, ads, knowledge graph, etc., and implies a read-only scrape. It does not mention auth, rate limits, or side effects, but given the GET nature, this is acceptable.

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

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

The description is front-loaded with purpose and then lists features and use cases. It is somewhat verbose but each sentence adds value, covering capabilities, parameters, and applications. Could be more concise but is 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's complexity (19 parameters, no output schema), the description is complete: it explains what the tool does, what parameters control, what results to expect, and when to use it. An agent can fully assess if this tool suits its needs.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by grouping parameters (e.g., 'location/uule, country (gl), language (hl, lr)') and providing high-level guidance (e.g., 'Use for person/company data enrichment'). It enhances understanding beyond individual parameter descriptions.

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

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

The description clearly states 'Get Google Search Results' and elaborates that it is a 'Full-featured Google Search scraper'. It distinguishes from sibling tools (e.g., the light version) by emphasizing rich capabilities and specific use cases like person/company data enrichment.

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 use cases: SEO rank tracking, keyword research, SERP-feature monitoring, competitor analysis, LLM grounding, and data enrichment. It implies that for simpler needs the light version may be used. However, it lacks explicit 'when not to use' statements.

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

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

No annotations provided. The description discloses it returns only organic results and basic pagination, omits rich blocks, and lists returned fields (title, link, snippet, position). It also mentions supported filters. This is sufficient behavioral context for a read-only 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?

Two short paragraphs: first sentence is a clear title, followed by a concise explanation of what it is, what it omits, what it supports, and what it returns. No redundant 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?

For a tool with 12 parameters and no output schema, the description covers purpose, filters, and return fields completely. It is adequate for an agent to select and invoke the tool correctly.

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

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

Input schema has 100% description coverage. The description adds value by grouping parameters (location/uule, country, language, etc.) and summarizing their purpose, exceeding the 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 'Get Google Light Search Results' with a specific verb and resource. It distinguishes itself from other Google SERP tools by explicitly listing omitted rich features (AI Overview, knowledge graph, PAA) and focusing on organic results. Use cases like high-volume keyword monitoring are listed.

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

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

The description explicitly states when to use: 'high-volume keyword monitoring, bulk rank tracking, backlink discovery, and any workflow where only the ten blue links matter.' It implies alternatives for rich results but does not name specific sibling 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 provided, the description carries the full burden. It discloses that it 'Scrapes' Google Shopping listings, mentions offset pagination, and details return fields including filter chips with hasdata_link. However, it lacks information on rate limits, authentication, or potential side effects.

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

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

The description is a single paragraph that is informative but somewhat lengthy. It could be more concise and better structured, especially the list of returned fields.

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 complexity (10 parameters, no output schema), the description covers purpose, parameters, and return values. It mentions pagination and filter chips. However, it lacks details on error handling, rate limits, or guidance for combining with other 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 100%, so the baseline is 3. The description adds some context (e.g., 'shoprs filter-helper IDs') but largely repeats parameter information already in the schema. It does not significantly enhance understanding 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 'Get Shopping Search Results' and lists specific use cases like e-commerce price tracking, catalog building, and promotion discovery. It distinguishes this tool from siblings such as hasdata_google_serp_serp_getSearchResults by focusing on Google Shopping listings.

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

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

The description mentions use cases but does not explicitly state when to use or when not to use this tool compared to alternatives. There is no direct comparison to sibling tools or guidance on 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?

With no annotations, the description carries the burden. It discloses the return fields (title, thumbnail, etc.) but does not mention rate limits, authentication, or side effects. It is adequate but not comprehensive.

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

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

The description is two paragraphs and front-loaded with functionality, followed by use cases. It is concise but could be slightly tighter without losing meaning.

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

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

Despite lacking an output schema, the description lists the return fields. It covers the main behavioral aspects for a scraping tool, though it could mention pagination limits or error handling.

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

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

Schema description coverage is 100%, so the description adds minimal extra meaning. It groups parameters (location/uule, country, language) but does not significantly enhance the schema's own 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 it scrapes the Google Short Videos carousel with query parameters. It distinguishes from sibling tools by specifying short videos, which is unique among the many Google SERP and platform-specific 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 lists explicit use cases like short-form content discovery and influencer research, providing context for when to use the tool. However, it does not mention when not to use it or compare to 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?

No annotations are provided, so the description carries full burden. It mentions deep-search mode taking longer, but does not disclose rate limits, authentication requirements, data source freshness, or error handling. The description adds some transparency about behavior but could be more comprehensive.

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

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

The description is a single, well-structured paragraph that front-loads the tool's purpose. It covers key aspects without being overly verbose. However, it could be slightly more concise or broken into bullet points for easier reading.

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 (31 parameters) and no output schema, the description covers input parameters well and mentions return values. It lacks details on error handling, pagination, or rate limits, which would improve completeness 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 100%, so baseline is 3. The description groups parameters (passenger mix, travel class, etc.) but does not add significant new information beyond the schema's detailed descriptions. It does not clarify parameter interactions or complex constraints beyond what the schema covers.

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 searches Google Flights for various trip types (one-way, round-trip, multi-city) and lists many parameters and use cases. It distinguishes itself from sibling tools, which cover different domains (e.g., Airbnb, Amazon, Google SERP).

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

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

The description mentions several use cases (travel-planning agents, fare monitoring, etc.), implying when to use the tool. However, it lacks explicit guidance on when not to use it or alternatives for similar flight search tools.

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

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

No annotations are provided, so the description carries the full burden. It mentions what is returned (interest-over-time, geo breakdowns, related queries) but lacks details on authentication, rate limits, or data freshness. Adequate but not fully transparent.

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 paragraph, efficiently covering purpose, parameters, and use cases. It is not overly long but could be slightly more structured. 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 tool's complexity (8 params, no output schema), the description explains output types and use cases well. It lacks details on restrictions or error handling, but covers the essential context for an agent 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 coverage is 100%, so baseline is 3. The description adds minor context (e.g., multiple vs single query per dataType) but does not significantly enhance understanding beyond the schema's own 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 starts with 'Get Google Trends Data' and elaborates with specific parameters and output types. It clearly distinguishes itself from sibling tools like SERP and Images, as no other tool serves Google Trends data.

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 lists use cases (keyword strategy, demand forecasting, etc.) but does not explicitly state when not to use or alternatives. However, the name and context make it clear this is the sole Google Trends tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It accurately describes a read-only operation ('Fetches') and lists the returned data fields, which implies no side effects or destructive actions. While it does not mention rate limits or authentication, the nature of the tool (simple GET of job details) makes the behavior sufficiently transparent.

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, consisting of a header and two sentences that front-load the purpose and use cases. Every sentence adds value without redundancy, making it easy for an AI agent to quickly understand the tool's function and applicability.

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 (one parameter, no output schema), the description is complete. It explains what the tool does, what parameters it takes, what data it returns (including a detailed list of fields), and provides relevant use cases. No additional information is needed for an agent to select and invoke 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 has 100% coverage, with the sole parameter 'url' described as 'The URL of the job vacancy to retrieve details for.' The description adds context by specifying it is a 'viewjob URL' from Indeed. This provides enough meaning beyond the schema, though the schema already covers the basics adequately.

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 'Fetches a single Indeed job posting by its viewjob URL' and enumerates the specific fields returned (title, company, salary, etc.). This distinguishes it from the sibling tool 'hasdata_indeed_listing_getJobListings' which likely returns a list of postings, thereby providing clear 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?

The description lists explicit use cases: 'ATS/CRM enrichment, compensation benchmarking, resume-to-JD matching with LLMs, and structured archival of postings discovered via the Indeed Listing endpoint.' It implicitly suggests when to use this tool (for detailed single job data) versus the listing sibling. However, it does not explicitly state when not to use it or mention alternatives beyond the listing endpoint.

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

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

No annotations are provided, so the description carries the full burden. It mentions offset-based pagination and return fields but does not disclose rate limits, authentication requirements, or page size limits. Behavioral insight is moderate.

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

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

The description is concise with two short paragraphs: the first covers functionality and parameters, the second lists use cases. Every sentence adds value without redundancy.

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

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

Given no output schema and no annotations, the description reasonably covers the tool's operation. It specifies returned fields and use cases. However, it lacks details on pagination limits, default sort behavior, and error handling, leaving minor 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 100%, so the schema already explains parameters well. The description only adds minor context (e.g., 'sort (relevance/date)' and 'offset-based pagination') that is already in the schema. No significant additional meaning 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 clearly states the tool searches Indeed job listings by keyword and location, and distinguishes itself from sibling tools (e.g., hasdata_indeed_job_getJobDetails) by focusing on listing retrieval. The verb 'get' combined with resource 'Indeed Job Listings' is specific.

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 lists specific use cases (job-market dashboards, hiring-trend analysis, etc.), providing context for when to use the tool. However, it does not explicitly state when not to use it or mention alternatives, though the sibling tools imply such boundaries.

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

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

No annotations are provided, so the description must carry full behavioral transparency. It states the tool 'Fetches' data, implying a read operation, and lists returned fields. However, it omits important details such as rate limits, authentication requirements, data freshness guarantees, and error handling for invalid handles. The description is adequate but could be more 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 is two sentences, beginning with a clear verb and resource. The first line 'Get Instagram Profile' is somewhat redundant with the title, but the overall structure is efficient and front-loaded with key information. Minor waste could be eliminated, but it remains concise.

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

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

For a simple tool with one parameter and no output schema or annotations, the description covers the core functionality and returned fields. However, it lacks details on error responses, data format, and any constraints. The description is minimally sufficient but not fully complete for an agent to anticipate all behaviors.

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

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

The input schema has 100% description coverage for the single parameter 'handle', explaining it must be a username without '@'. The tool description adds minimal extra meaning beyond restating that the handle is used. Since the schema already fully documents the parameter, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves a public Instagram profile by handle, listing specific returned fields (full name, biography, etc.). The sibling tools are all for different platforms (Amazon, Google, etc.), making this tool distinct and uniquely identified for Instagram profile data.

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 provides several use cases (enrich CRM, verify influencer reach, monitor competitors, build datasets), giving clear context for when to use it. However, it does not mention when NOT to use it or compare it to other tools, but given the lack of similar tools on the server, this is a minor omission.

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

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

No annotations provided, so description must disclose behavior. It mentions pagination and returned fields but lacks details on rate limits, authentication, error handling, or output structure.

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 two paragraphs; first sentence repeats the title. Could be more front-loaded and concise. Adequate but not 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?

No output schema, so description must detail return format. It lists fields but not structure or pagination behavior. Missing details on how to interpret results, pagination limits, or total pages.

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

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

Schema description coverage is 100%, so baseline is 3. Description reinforces that keyword is a zipcode but adds no new meaning beyond the schema 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 it retrieves Redfin real estate listings by zipcode with pagination, lists specific fields returned, and distinguishes from sibling tools like the property details endpoint.

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 use cases (market research, lead generation, trend analysis) and mentions feeding URLs to the property endpoint. Does not explicitly say when not to use or list alternatives, but context is clear.

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

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

No annotations, but description discloses it fetches a full property page. It doesn't mention rate limits or authentication, but for a simple GET with one parameter, behavior is sufficiently transparent.

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

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

Front-loaded with title and main action. Lists many data points, which is informative but slightly verbose. No wasted sentences, overall concise for the 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?

With one parameter and no output schema, the description explains input, output fields, and use cases thoroughly. No gaps for a simple fetch 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 already has 100% coverage with a clear description. The tool description adds no extra parameter details beyond the schema, so 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 it fetches Redfin property details by URL, listing specific data fields. It distinguishes from sibling tools like listing search and Zillow by naming Redfin and detailing use cases.

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?

Lists explicit use cases (CMA reports, valuation models, etc.) and implies differentiation from listing endpoints. Lacks explicit when-not-to-use or alternatives, but context is clear.

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

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

No annotations provided, but the description does not disclose any side effects, rate limits, or authentication requirements. It adequately indicates a read operation and public URL requirement.

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

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

Three sentences with no fluff; first sentence is a clear title, second describes functionality, third provides usage direction. Excellent structure.

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

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

Despite lack of output schema, description details return fields and pagination. The tool's purpose and integration with sibling are fully covered for its 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 100%, so schema already documents params. Description adds context (limit up to 250, pagination, public URL) but does not significantly augment semantics beyond 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 lists Shopify collections with pagination, and distinguishes from sibling hasdata_shopify_products_getProducts by mentioning returned handles as input to that endpoint.

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

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

Explicitly explains how to use the returned handles with the Shopify Products endpoint and provides use cases like mapping taxonomies. Lacks explicit when-not-to-use instructions but overall strong 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 read-only data pulling and pagination, but lacks details on rate limits, authentication requirements for public stores, or error handling. Annotations are absent so description carries full burden.

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

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

Front-loaded with clear action and resource. Use cases are listed but in prose; could be more structured but remains 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 purpose, parameters, and use cases, but omits details on pagination looping, error scenarios, and potential restrictions. Adequate but not fully comprehensive.

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 covers all parameters, description adds context like 'public' URL and limit up to 250, reinforcing schema 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?

Clearly states it retrieves products from a Shopify store, listing specific return fields and distinguishing it from sibling collection 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?

Lists use cases but does not explicitly compare to alternatives or state when not to use this tool. Implicitly differentiated from collections 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?

Discloses many behavioral traits: proxy types, JS rendering, jsScenario actions, blocking options, output formats. However, lacks explicit mentions of rate limits, cost, or potential IP blocking. Without annotations, description mostly sufficient but could be slightly more 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?

Description is front-loaded with main purpose, then lists features, then returns, then use cases. Some redundancy in listing features again in the use case section, but overall well-structured and 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 20 parameters and no output schema, the description covers major features, return types, and use cases. It could be more complete by mentioning pagination or error behavior, but adequate for a 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?

Schema coverage is 100% with detailed descriptions. The description adds high-level context but does not significantly improve parameter understanding beyond schema. Baseline score of 3 is appropriate.

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

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

The description clearly states 'Universal web scraper' and lists comprehensive capabilities. It explicitly distinguishes itself from sibling tools (site-specific APIs) by positioning as a fallback/universal fetcher. The verb 'scrape' and resource 'web page' are specific.

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

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

Explicitly states when to use: 'fallback/universal fetcher for sites without a dedicated API, for scraping JS-heavy SPAs, bypassing bot protections, ...'. Implies alternatives: sibling tools for specific sites.

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 full burden. It describes the tool as scraping a single listing (read operation) and lists returned data, but does not disclose potential rate limits, authentication needs, or behavior on invalid URLs.

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

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

Three succinct sentences: first states action and output, second provides use cases. No redundant information. Front-loaded with key details.

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 no output schema, the description covers purpose, data returned, and use cases. Lacks explanation of return format or error handling, but still adequate for an 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?

The single parameter 'url' is fully described in the schema (100% coverage). The description adds minimal extra meaning beyond schema, only implying the URL should be from YellowPages. 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 explicitly states it scrapes a single YellowPages business listing URL and returns specific data fields (NAP, hours, ratings, etc.). It clearly differentiates from sibling tools like search endpoints or other place details tools (e.g., Google Maps, Yelp).

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 concrete use cases: hydrating leads, building B2B databases from URLs collected via Search, validating business legitimacy. Implies prerequisite of having a YellowPages URL, but does not explicitly state when not to use or 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?

No annotations exist, so the description carries full burden. It discloses that the tool returns businesses with specific fields and uses page-based pagination. However, it does not mention rate limits, authentication, or side effects.

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

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

The description is three sentences, each packed with useful information. No fluff, clearly structured from summary to use case to output details.

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 5 parameters, 2 required, and no output schema, the description lists all return fields, explains pagination, and gives concrete usage scenarios. It is complete for the complexity level.

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 covers all parameters with descriptions (100% coverage). The description adds value by explaining the sort options, domain targeting, and pagination pattern, reinforcing the schema's meaning.

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

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

The description explicitly states 'Get YellowPages Search Results' and details the action: runs a business search by keyword and location with sort, domain, and page options. It distinguishes from sibling tools by mentioning the YellowPages Place endpoint for enrichment.

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

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

The description provides clear use cases: B2B lead generation by niche and city, feeding URLs into Place endpoint, or building prospect lists. It implies when to use but does not explicitly state when not to use or compare to other search tools.

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

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

With no annotations provided, the description bears the full burden. It lists returned fields, which adds beyond the schema, but it does not disclose whether the operation is read-only, any required permissions, or potential side effects. The agent must infer safety from 'fetches'.

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

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

The description is three sentences long and concise, front-loading the purpose and then listing return fields and use cases. It is clear and efficient, though a slight structuring issue (e.g., bullet points) could improve 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?

Given the absence of an output schema, the description should hint at the return structure. It lists fields but does not explain format (e.g., single JSON object, pagination). Edge cases like missing place ID are not addressed. Sibling differentiation from Google Maps place tool is absent.

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

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

Schema coverage is 100% with both parameters described in the schema. The description mentions 'domain targeting' but adds no additional semantic detail beyond what the schema already provides. The baseline of 3 is appropriate.

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

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

The description clearly states it 'Fetches a single Yelp business by Yelp ID or alias', which is a specific verb+resource. It lists the returned fields and provides three distinct use cases, distinguishing it from the sibling 'hasdata_yelp_search_getSearchResults' which returns multiple 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?

The description explicitly lists use cases (enrich leads, monitor competitor, validate hours/amenities), giving clear context for when to use this tool. However, it does not mention when not to use it or explicitly compare it to alternatives like the Yelp search 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?

No annotations are provided, and the description does not disclose behavioral traits such as rate limits, authentication requirements, or whether the operation is read-only. The description focuses on functionality but lacks transparency about side effects or constraints.

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 paragraph of five sentences, efficiently covering purpose, parameters, and output usage. It front-loads the main action and is free of redundant language, though it could be slightly more structured with bullet points.

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

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

Given no output schema, the description adequately details the return fields (alias/ID, name, categories, rating, etc.) and explains how the output can be used. All five parameters are covered in context, making the tool understandable 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 100%, but the description adds value by clarifying the format of the `l` parameter (map-bounded radius example) and explaining offset-based pagination for `start`. This supplements the schema definitions 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 description clearly states 'Get Yelp Search Results' and explains it performs a business search by keyword and location with optional parameters. It distinguishes itself from the sibling `hasdata_yelp_place_getPlaceDetails` by explicitly mentioning that returned aliases can be used as input to that endpoint.

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 use cases: 'to power local-discovery UIs, or to build market-share/competitor datasets', and directs users to the Yelp Place endpoint for full details. However, it does not explicitly state when not to use this tool or describe alternatives among 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?

No annotations are provided, so description carries full burden. It mentions pagination but does not explain how page parameter works or clarify limits. For a read tool, it is adequate but missing details on result 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 concise, front-loads purpose, and uses bullet-point-like use cases. However, the return fields list could be structured more clearly.

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 (33 params), the description covers purpose and return fields but lacks details on pagination behavior, default sorting, and any limitations. 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 coverage is 100%, so baseline is 3. The description adds value by listing the return fields (address, Zestimate, etc.), which are not in the schema. However, the filter listing is redundant with 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 Zillow real estate listings by keyword with rich filters and pagination. It distinguishes from the sibling tool hasdata_zillow_property_getPropertyDetails by mentioning it collects URLs for that endpoint.

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 lists specific use cases such as market dashboards and rental analysis, and implies workflow with property endpoint. However, it does not explicitly compare with other real estate siblings like Redfin listing 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?

Discloses optional email extraction and cost increase. Without annotations, describes returned data but not side effects, errors, or rate limits. Adequate but not comprehensive.

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?

Title and three sentences: action, data list, use cases. No wasted words, front-loaded with key 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?

Lists extensive data fields (price history, Zestimate, etc.) despite no output schema. Sufficient for agent to decide to call. Lacks error or pagination details but acceptable.

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 covers both parameters with descriptions. Description adds context for email extraction ('plus email when enabled') but does not significantly enhance beyond schema. Schema coverage is 100%.

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 action (Get Zillow Property Details) and resource (property by URL/zpid). Lists returned data and use cases, distinguishing it from sibling listing 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?

Explicitly lists use cases (valuation models, CMA generation, etc.), implying when to use. Does not explicitly mention alternatives or when not to use, but siblings like getRealEstateListings provide implicit contrast.

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