enterprise-mcp-gateway

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

Annotations already provide readOnlyHint=true and openWorldHint=true, so the safety profile is clear. The description adds useful behavioral details: it returns specific fields (titles, authors, abstracts, PDF links) and gives example queries. This complements the annotations well, though it does not mention pagination, rate limits, or date 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 extremely concise: two sentences and a short bullet-style list. It front-loads the core purpose immediately and each sentence adds necessary information without redundancy. Every element earns its place.

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

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

Given there is no output schema, the description covers return values (titles, authors, abstracts, PDF links). Parameters are well explained. For a simple search tool, this is mostly complete. Minor omissions like pagination or sorting options prevent a 5.

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 0% parameter description coverage, so the description must compensate. It does so by listing both parameters (query and max_results) with an example for query and the default value for max_results. This provides practical usage guidance beyond the raw schema. However, it could include more details like query format or allowed values.

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

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

The description clearly states 'Search arXiv for academic papers' and lists return fields (titles, authors, abstracts, PDF links). It distinguishes itself from sibling tools like 'academic-research__search_google_scholar' by specifying the database (arXiv). The verb 'search' and resource 'arXiv' are specific and unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives such as 'academic-research__search_google_scholar' or 'developer-tools__search_arxiv'. It does not mention any prerequisites, exclusions, or context for selection. The agent would have to infer usage from the name alone, which is insufficient.

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

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

Annotations already indicate readOnlyHint and openWorldHint. The description adds that it returns specific fields (titles, authors, citations, links) and accepts a query, but does not disclose additional behaviors like rate limits, pagination, or result ordering. The added value beyond annotations 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 efficient: one sentence for purpose and a clear bullet list for parameters. Every sentence serves a purpose. No redundancy or filler.

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

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

For a simple search tool with two parameters and no output schema, the description adequately covers input semantics and return fields. It could mention if results are sorted by relevance or date, but it is sufficiently complete given the tool's simplicity.

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

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

Schema coverage is 0%, meaning descriptions must compensate. The description provides an example for query ('deep learning medical imaging') and explains max_results as 'Maximum papers to return (default 10)'. This adds meaningful context beyond the schema's type-only definitions.

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 searches Google Scholar for academic papers and specifies the return fields (titles, authors, citations, links). This distinguishes it from sibling tools like search_arxiv, which searches a different repository.

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 the tool's purpose but does not explicitly state when to use this tool over alternatives such as academic-research__search_arxiv or developer-tools__search_google_scholar. The context is implied for academic paper searches, but no exclusions or heuristics are given.

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

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

Annotations already declare readOnlyHint=true, so the description doesn't need to reinforce that. It adds that it returns price ranges and dealer inventory, but no further behavioral details like data sources, rate limits, or caching. Acceptable but not rich.

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-loading the purpose. The args are listed in a structured way. It could be more scannable with bullet points, 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?

For a read-only analytics tool with no output schema, the description gives a high-level summary of return values ('price ranges and dealer inventory') but lacks specifics on format or structure. Leaves some ambiguity about what exactly is returned.

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

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

Schema coverage is 0%, so description bears full burden. It lists all three parameters with examples and clarifies that year is optional with default 0. This adequately adds meaning beyond the raw schema.

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

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

Description clearly states the tool analyzes car market prices for a specific make/model and returns price ranges and dealer inventory. It distinguishes itself from sibling 'automotive__search_cars' which likely searches for car listings, not market analysis.

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

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

The description implies usage for price analysis of a specific make/model, but does not explicitly contrast with siblings or state when not to use. No alternative tools are mentioned.

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

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

Annotations already declare readOnlyHint=true (safe read) and openWorldHint=true (data may change). The description adds that it searches Cars.com and returns specific fields, consistent with annotations. No contradictions, but limited additional insight beyond annotations.

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

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

Extremely concise: one sentence summarizing purpose and return data, followed by a clean Args list. No redundant information, front-loaded with key action.

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

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

For a straightforward 4-parameter search tool with no output schema, the description covers purpose, parameters, and return fields. Lacks details on response format or pagination, but adequate for basic usage.

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 0% description coverage. The description's Args section explains each parameter (make, model, zip_code, max_results) with examples and defaults, effectively compensating for the missing 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?

Description clearly states the tool searches Cars.com for vehicle listings and specifies returned data (prices, mileage, dealer info). The verb 'search' and resource 'Cars.com' are specific, distinguishing it from the sibling 'automotive__car_market_analysis'.

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

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

No explicit guidance on when to use this tool versus alternatives. It does not mention when not to use or provide comparisons with the sibling 'automotive__car_market_analysis' or similar search tools from other domains.

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

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

Annotations already set readOnlyHint=true and openWorldHint=true. The description adds that it uses CoinGecko and that an empty coins list yields top coins, but does not disclose other behavioral traits like rate limits, data freshness, or error handling. It provides minor context beyond annotations.

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

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

The description is concise, using a bracketed tag '[Crypto Intelligence]' for categorization, and an 'Args:' section for parameters. Each sentence is functional, though the structure could be slightly more formal.

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 no output schema, the description does not specify the return format or fields, leaving the agent to infer from 'prices and market data'. This is adequate for a simple fetch tool but lacks completeness for precise understanding.

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

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

Despite 0% schema description coverage, the description explains each parameter: 'coins: List of coin IDs (e.g. ['bitcoin', 'ethereum']). Empty for top coins.' and 'max_results: Max results (default 50)'. This adds significant meaning beyond the schema's type and default values.

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

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

The description clearly states 'Get current cryptocurrency prices and market data from CoinGecko', specifying the verb (Get), resource (prices and market data), and data source (CoinGecko). However, it does not differentiate from the sibling tool 'finance__get_crypto_prices', which likely has a similar purpose.

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

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

Provides a usage hint: 'Empty for top coins' for the coins parameter, indicating common usage. No explicit guidance on when to use this tool versus alternatives like 'crypto__exchange_rates' or 'finance__track_crypto_portfolio', nor when not to use it.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=true. The description adds that rates are 'current' and that base_currency defaults to USD, which is consistent but does not disclose additional behavioral traits beyond annotations.

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

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

The description is very short and to the point, using a prefix for categorization. Every part serves a purpose, though it could be slightly more 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 tool's simplicity (one optional parameter, read-only), the description is minimally adequate. However, it does not specify what exchange rates are returned (e.g., all currencies vs. a specific set) or the return format, which could leave ambiguity for the 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 description adds meaning to the single parameter 'base_currency' by explaining it as a currency code with a default of 'USD'. Since schema description coverage is 0%, this provides essential context for selecting and using the parameter.

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

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

The description clearly states 'Get current currency exchange rates' with a '[Crypto Intelligence]' prefix, indicating a crypto-specific scope. This distinguishes it from general exchange rate tools like 'finance__get_exchange_rates' but does not explicitly differentiate from 'crypto__crypto_prices'.

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

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

No guidance on when to use this tool vs alternatives. There is no mention of when not to use or any prerequisites. The description is minimal and lacks usage context.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds value by specifying the type of data returned (stats), but does not mention any additional behavioral details like rate limits or response format.

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

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

The description is very concise with a single sentence and an args block. It is front-loaded with the tool title and action, wasting no words.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the purpose and parameter format adequately. Missing is a brief note on what the returned data looks like, but not critical.

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

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

Schema has 0% description coverage, but the description provides full documentation for the repo parameter, including format and examples. This adds significant 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 it gets GitHub repository stats and lists specific metrics (stars, forks, issues, language, description, recent activity). It distinguishes from sibling tools like search_github by focusing on stats retrieval.

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

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

The description does not provide explicit when-to-use or when-not-to-use guidance. It implies usage through the listed stats, but alternatives such as github__get_repo_stats are not mentioned.

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

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

Annotations already declare readOnlyHint and openWorldHint. The description adds no additional behavioral details beyond listing returned fields; it does not mention rate limits, pagination, or other 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 very concise: two sentences plus an Arg line. It is front-loaded with the purpose and includes only essential information with no wasted words.

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

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

Given no output schema, the description lists the returned fields (version, downloads, etc.) which is helpful. However, it could be more complete by specifying whether it fetches latest version or specific version, or details about pagination.

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

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

With 0% schema description coverage, the description compensates by explaining that the parameter is an npm package name and provides examples. This adds meaningful context beyond the raw 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 gets npm package details and lists specific fields (version, downloads, dependencies, description, maintainers). It uses a specific verb 'Get' and resource 'npm package', and distinguishes from sibling tools like get_pypi_package and get_github_repo.

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 examples of package names but does not explicitly state when to use or not use this tool. It implies usage for npm package queries, but lacks explicit guidance on alternatives or 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?

Annotations already indicate readOnlyHint=true and openWorldHint=true. The description adds value by specifying what data is returned (version, downloads, dependencies, description), which is beyond the annotations. No contradictions.

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

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

The description is very concise, using a single line for purpose and a short Args section. Every sentence is informative and front-loaded.

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

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

For a simple 1-parameter tool with no output schema, the description is largely complete. It mentions the return data but could note potential error handling (e.g., missing package). Still adequate.

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

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

With 0% schema description coverage, the description compensates by explaining the parameter 'package_name' as 'PyPI package name' and providing examples. This adds crucial meaning beyond the bare schema type.

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

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

The description clearly states the tool's purpose: 'Get Python package details from PyPI' and lists specific data returned (version, downloads, dependencies, description). It distinguishes itself from siblings like 'get_npm_package' by targeting PyPI packages.

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

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

The description implies usage for Python packages by providing example names and specifying PyPI, but it does not explicitly state when to use this tool over alternatives or provide any exclusion criteria. No guidance 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?

Annotations already declare readOnlyHint=true, so the description does not need to restate read-only behavior. However, it adds no further behavioral context such as rate limits, pagination behavior, or whether results are sorted. The lack of output schema means return value format is unexplained, which is a gap for a search 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 extremely concise: two sentences defining the tool's domain and listing parameters with examples. Every sentence adds value, and the Args format is well-structured. No wasted words.

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

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

For a tool with two parameters and no output schema, the description covers parameter behavior well but omits what the results look like (e.g., titles, abstracts, links). The domain restriction is helpful, but the return format is unexplained. Since no output schema exists, the description should ideally provide this 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?

Despite the schema having 0% description coverage, the description thoroughly explains both parameters: 'query' with an example search string and 'max_results' with its default value. This adds significant meaning beyond the raw schema. Excellent compensation for missing 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 searches arXiv for academic papers in specific fields (CS, ML, AI, physics, math). However, it does not differentiate from the sibling tool 'academic-research__search_arxiv', which likely performs the same function but under a different namespace. The purpose is clear but lacks sibling distinction.

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

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

There is no guidance on when to use this tool over alternatives. Sibling tools include 'academic-research__search_arxiv' and 'academic-research__search_google_scholar', but the description provides no context for choosing this one. Additionally, no exclusions or prerequisites are mentioned.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, indicating safety. The description adds that it returns specific data fields, which is useful but does not disclose potential rate limits, pagination, 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 very concise: a single sentence for purpose, followed by a clear list of arguments. No unnecessary words, and the key information is front-loaded.

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

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

For a simple search tool with 2 parameters and annotations, the description is mostly adequate but misses details on result sorting, pagination, or rate limits. Could be more 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?

With schema description coverage at 0%, the description adds meaning by listing parameters, providing example queries for 'query', and noting the default for 'max_results'. This compensates for the bare schema.

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

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

The description clearly states it searches GitHub repositories by keyword and lists returned fields (stars, descriptions, languages). However, it does not differentiate from the sibling tool 'github__search_repos', which may have similar functionality.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'github__search_repos' or other search tools. No exclusions or context for appropriate use.

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

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

Annotations already indicate readOnlyHint=true. The description adds no behavioral context beyond the read-only nature, such as rate limits, pagination, or result format. Minimal value added beyond annotations.

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

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

Extremely concise: one sentence for purpose, then two parameters explained. No wasted words, front-loaded with the core action. Ideal length.

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

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

For a simple search tool with two parameters and no output schema, the description covers purpose and parameters adequately. It lacks details on return format or pagination, but is mostly complete for a straightforward query.

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

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

Schema coverage is 0%, so description must add meaning. It explains 'query' with examples and notes the default for 'max_results'. This adds some semantics, but does not cover additional details like allowed query syntax or maximum 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?

Clearly states 'Search Google Scholar for academic papers, citations, and research' with a specific verb and resource. Distinguishes from sibling tools like `developer-tools__search_arxiv` and `academic-research__search_google_scholar` by targeting Google Scholar.

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 example queries but no explicit guidance on when to use this tool over alternatives. Sibling tools include many search tools, and the description does not mention when to prefer this tool (e.g., for academic vs. general web search).

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

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

Annotations declare readOnlyHint=true and openWorldHint=true. Description adds no further behavioral context (e.g., rate limits, pagination, result format). With annotations, the description is adequate but not enriched.

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?

Extremely concise: one line purpose, bulleted parameters. No wasted words. Information is front-loaded.

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

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

Lacks output description (no output schema). For a simple search tool, it's adequate but leaves the agent guessing about return format. Could mention that results include question titles and links.

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

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

Schema coverage is 0%. Description provides examples for query and states default for max_results, adding helpful context beyond the schema. Could include more details like query format.

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

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

Description clearly states 'Search StackOverflow for programming questions and answers', specifying verb and resource. Distinguishes from sibling developer tools like search_github and search_arxiv.

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

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

No explicit when-to-use or alternative guidance. Usage is implied by the tool name and description, but could be improved by contrasting with 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, indicating a safe read operation with variable output. The description complements this by specifying the exact record types returned, adding behavioral context beyond the annotations. It does not cover error handling or rate limits, but for a simple lookup tool, this is sufficient.

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

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

The description is extremely concise: two sentences and a parameter definition. It front-loads the core action immediately and avoids unnecessary words. Every sentence is purposeful, making it easy for an agent to parse quickly.

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

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

For a tool with one required parameter, readOnly and openWorld annotations, and no output schema, the description is fairly complete. It specifies the return content (record types). It could mention that it queries public DNS servers, but this is implicit. Overall, it covers the essential context without exceeding what's needed.

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

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

With schema description coverage at 0%, the description carries the burden for parameter explanation. It adds 'Domain name (e.g. 'example.com')', which provides an example format and clarifies the expected input. While it doesn't delve into format constraints (e.g., no protocol), the single-parameter simplicity makes this adequate.

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

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

The description clearly states the tool looks up DNS records for a domain and lists the specific record types returned (A, AAAA, MX, CNAME, TXT). This provides a precise verb-resource combination, distinguishing it from other DNS-related tools like whois or SSL checks, though it doesn't explicitly differentiate from the sibling 'seo-web-analysis__check_dns'.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives. While it clearly indicates it is for DNS record lookups, it lacks context about when not to use it (e.g., for WHOIS or SSL) and does not name similar tools to avoid confusion. Given the presence of a similar sibling 'seo-web-analysis__check_dns', more differentiation would be helpful.

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

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

Annotations already declare readOnlyHint and openWorldHint. Description adds return field details but does not elaborate on behavioral aspects beyond what annotations provide. No side effects mentioned, but readOnlyHint covers safety.

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?

Extremely concise: two sentences with an explicit args section. No unnecessary words.

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

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

Given the simple nature of the tool (1 param, no output schema, annotations present), the description is sufficiently complete: it states purpose, return fields, and parameter format. No additional context needed.

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

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

Single parameter 'ip' has description listing the format and an example ('8.8.8.8'), compensating for 0% schema description coverage. Clearly defines expected input.

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 'Look up geolocation for an IP address' and specifies returned fields (country, city, ISP). Differentiates from sibling tools like dns_lookup, ssl_check, whois_lookup by focusing on IP geolocation specifically.

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

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

No explicit guidance on when to use vs alternatives. The purpose is clear but no 'when not to use' or alternative tool mentions. Sibling tools exist in same domain but no contrast is provided.

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

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

Annotations already declare readOnlyHint=true, indicating a safe read operation. Description adds no further behavioral details (e.g., network dependency, error handling, or output structure beyond listed fields).

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 sentences, covering purpose and parameter. The '[Domain Intelligence]' prefix is redundant with the tool name, but overall it is succinct and front-loaded.

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

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

Lacks output schema, but mentions return fields. Does not cover error cases, timeout, or difference from sibling seo-web-analysis__check_ssl. Adequate for a simple tool 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?

Although schema has 0% description coverage, the description adds a parameter explanation with a format example ('example.com'), providing meaning beyond the raw 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?

Clearly states the tool checks SSL certificates for a domain, and specifies the return fields (issuer, expiry, validity). This is specific and differentiates from generic lookup tools.

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

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

The description does not provide guidance on when to use this tool vs alternatives like seo-web-analysis__check_ssl. It implies a straightforward SSL check but lacks exclusionary or alternative 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?

Annotations already convey readOnlyHint and openWorldHint. The description adds that it returns specific fields (registrar, dates, nameservers), which is useful. However, it does not disclose error conditions, rate limits, or validity requirements beyond the domain format example.

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 plus an Args line, no fluff. Every sentence adds value: purpose, returned fields, parameter format. Front-loaded with the action verb.

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 partially explains return values but omits details like date types (creation, expiration) and nameserver format. Sibling tools are not referenced for comparison, leaving the agent to infer 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?

With schema description coverage at 0%, the description compensates by explaining the 'domain' parameter with a format example (e.g., 'example.com'). This adds meaning beyond the raw schema. Could be improved by specifying acceptable TLDs or that the domain should be registrable.

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 looks up WHOIS information for a domain and lists returned fields (registrar, dates, nameservers). This distinguishes it from domain-intelligence siblings like dns_lookup and ip_geolocation, but does not differentiate from seo-web-analysis__lookup_whois which may be identical.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites or exclusions. Siblings like dns_lookup and ssl_check exist but no comparison is provided.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. Description adds specific outputs but does not disclose potential failures, rate limits, or dependencies (e.g., store must be live). Provides adequate but minimal extra 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?

Description is concise: one sentence listing outputs and one line for parameter with example. No wasted words; 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 simple tool (1 param, no output schema, clear annotations), description covers key outputs. Lacks mention of error handling, but overall sufficient for selection and invocation.

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

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

Only parameter 'url' has a format example in description ('https://store.example.com'), adding value over the schema which lacks description. However, no additional semantics like accepted URL patterns or restrictions.

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

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

Description clearly states verb 'Analyze' and resource 'Shopify store', and lists specific outputs (tech stack, theme, apps, traffic estimates, store metadata). It distinguishes from sibling 'get_store_products' which focuses on 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?

No guidance on when to use this tool vs alternatives. No mention of prerequisites or when not to use it. Sibling tools exist (e.g., 'get_store_products') but no differentiation provided.

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

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

Annotations already declare readOnlyHint and openWorldHint. The description adds that it returns product details and default max_results, but does not mention pagination, rate limits, or other behavioral details. Minimal added context.

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

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

The description is concise and front-loaded: starts with category and purpose, then lists parameters. No redundant or irrelevant information. Every sentence is useful.

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 two-parameter tool with no output schema and good annotations, the description covers the basics (what it returns). However, it does not specify output format, pagination, or any limitations, leaving some gaps for a complete understanding.

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

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

Schema coverage is 0%, but the description provides brief yet clear meaning for both parameters: url as Shopify store URL with example, and max_results as maximum products with default. Compensates well for missing 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 gets products from a Shopify store, listing specific fields like prices, titles, images, and variants. It distinguishes from sibling 'analyze_shopify_store' by focusing on product listing.

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

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

The description explains what the tool does but does not explicitly tell when to use it versus alternatives like 'analyze_shopify_store'. Usage context is implied but not contrasted.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. Description adds source (CoinGecko) and default behavior for empty coins. No mention of rate limits or pagination, but adequate 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?

Concise and well-structured: one sentence for purpose and source, one for returned fields, then an Args section. No unnecessary words.

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

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

Lists returned fields but does not specify the exact structure (e.g., list of dicts). For a simple tool with no output schema, this is mostly sufficient but could be slightly more detailed about 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 0% so description carries full burden. Clearly explains coins as comma-separated IDs and max_results as max number of coins with default 20. Adds examples and context 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?

Clearly states it gets cryptocurrency prices and market data from CoinGecko, listing specific fields (price, market cap, 24h change, volume). Distinguishes from siblings like finance__get_stock_data by focusing on crypto.

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 examples of how to use coins parameter (comma-separated IDs or empty for top coins) and mentions default max_results. Lacks explicit when-to-use vs alternatives like crypto__crypto_prices, 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description of returning rates is consistent. However, it adds no extra behavioral context (e.g., data freshness, rate limits). No contradiction with annotations.

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

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

Extremely concise: two short sentences that are front-loaded with purpose. No unnecessary words or repetition.

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

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

Given no output schema, the description only vaguely states 'Returns conversion rates for major world currencies.' It could be more informative about the return format (e.g., object with currency codes and rates). 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 0% (parameter lacks description in schema), but the description compensates by explaining base_currency and providing examples. This adds meaningful semantic value beyond the bare schema.

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

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

Description clearly states 'Get current currency exchange rates' with a specific verb and resource. It distinguishes from sibling tools like crypto__exchange_rates and finance__get_crypto_prices by focusing on fiat currencies.

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

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

No explicit guidance on when to use this tool versus alternatives like crypto__exchange_rates or finance__get_stock_data. The description only mentions the base_currency parameter but does not provide context for tool selection.

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

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

Annotations already indicate readOnlyHint and openWorldHint. The description adds value by specifying the data source (Yahoo Finance) and the types of data returned (price, volume, market cap, etc.), which goes beyond the annotations.

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

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

The description is very concise (two sentences) and well-structured: category, action, data specifics, then parameter details. No filler.

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

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

Given the simple nature of the tool (one parameter, no output schema, annotations present), the description covers purpose, source, return fields, and parameter format. It is sufficiently complete for an AI 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 schema provides only the name and type for 'ticker', with 0% coverage. The description explains it's a stock ticker symbol and gives examples, adding crucial context that the schema lacks.

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 gets stock market data for a ticker symbol from Yahoo Finance, and lists specific data fields. However, it does not explicitly differentiate from sibling tools like yahoo-finance__get_stock_quote or finance__get_crypto_prices.

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

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

No guidance on when to use this tool versus alternatives (e.g., yahoo-finance__get_stock_quote for a quick quote, or finance__screen_stocks for screening). No when-not or prerequisites.

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

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

The description adds minimal behavioral context beyond the annotations. Annotations already indicate readOnlyHint=true and openWorldHint=true, which the description does not contradict. It mentions the source (Finviz), but does not disclose additional traits like rate limits, result format, or typical 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, starting with a clear category header, followed by a brief purpose statement, and then parameter details. Every sentence adds value without unnecessary fluff.

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

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

The description lacks important details such as what the tool returns (e.g., a list of tickers, full stock data, or a table). With no output schema, this omission reduces completeness. Also, it does not specify the market scope (e.g., US equities) despite similar sibling tools for global markets.

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

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

Schema description coverage is 0%, so the description carries full responsibility. It provides clear explanations for both parameters, including an example for 'screener_url' (e.g., 'cap_large,sec_technology'). This adds significant value beyond the bare schema.

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

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

The description clearly states the tool screens stocks using Finviz stock screener and lists example filters. It distinguishes from sibling tools like 'finance__get_stock_data' by focusing on screening rather than retrieving specific stock data. However, it does not explicitly differentiate from other Finviz-based screeners.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as the global-equities-screener tools for specific markets. It lacks comparison or context for choosing this tool over others.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so tool is safe and read-only. Description adds that it returns specific data but no additional behavioral details beyond what annotations provide.

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

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

Three concise sentences: first states purpose and returns, last explains the parameter. 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?

For a simple one-parameter tool with no output schema, description covers what it does and returns. No missing critical details, though could mention limitations like max number of coins.

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

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

With 0% schema description coverage, the description compensates by explaining the 'coins' parameter format (comma-separated list) and providing an example. This adds meaning beyond the schema's type and default.

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

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

Description clearly states it tracks crypto portfolio prices and returns current prices, 24h changes, and market caps. Differentiates from siblings like 'crypto__crypto_prices' by mentioning 'portfolio' and specific 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?

No explicit guidance on when to use this tool versus similar siblings (e.g., 'finance__get_crypto_prices'). Lacks when-to-use or when-not-to-use recommendations.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=true, so the description does not need to reiterate safety. However, it adds little beyond stating 'compare side by side' and does not explain what data is compared or how results are structured, leaving behavioral details vague.

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

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

The description is extremely concise: two lines plus an args block. It immediately states the core purpose and provides clear parameter guidance with an example. Every sentence adds value without redundancy.

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

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

Given the simplicity (one parameter, no output schema), the description is adequate but leaves ambiguity about the output format and what metrics are compared. It could be more complete by listing typical comparison aspects (stars, forks, etc.) or noting the response structure.

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 for 'repos' is just an array of strings with no description. The description adds semantics by explaining the format ('owner/repo' strings) and providing an example (['facebook/react', 'vuejs/vue']), which is valuable 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's purpose: 'Compare multiple GitHub repositories side by side.' The verb 'compare' and resource 'repositories' are specific, and it distinguishes itself from sibling tools like `developer-tools__get_github_repo` and `github__get_repo_languages` by focusing on multi-repository comparison.

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

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

The description implies usage for comparing multiple repos but does not explicitly state when to use this tool over alternatives (e.g., `get_github_repo` for single repo details). No when-not or alternative guidance is provided, leaving the agent to infer based 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?

Annotations already indicate read-only and open-world hints. Description adds that it returns a 'language breakdown', implying a mapping of languages to bytes. However, it does not detail output format, potential errors, or rate limits. Adequate but not rich.

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?

Extremely concise: one purpose sentence and a simple arg list. No unnecessary 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?

For a simple tool with two required parameters and no output schema, the description covers the essential: what it does and what inputs are needed. Could be improved by clarifying the output (e.g., mapping of language to bytes or percentage).

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 0% description coverage for parameters. Description compensates by providing explicit examples for owner ('microsoft') and repo ('vscode'), clarifying their meaning. Good but could add constraints like case-sensitivity.

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

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

Description clearly states verb 'Get' and resource 'programming language breakdown for a GitHub repository'. It is specific and distinguishes from sibling tools like get_repo_stats and search_repos which handle different aspects of repositories.

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

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

No guidance on when to use this tool versus alternatives. Does not mention typical use cases, prerequisites (e.g., repository must exist), or when not to use. Only provides parameter examples.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, indicating a safe read operation. The description adds context by listing example statistics (stars, forks, issues, activity) but does not disclose additional behavioral traits like rate limits or authentication needs.

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

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

The description is concise and front-loaded with the purpose. Every sentence adds value—the prefix identifies the category, the main sentence defines the action, and the parameter descriptions are succinct.

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 two required parameters and no output schema, the description adequately covers purpose and parameter meanings. It lists included statistics (stars, forks, issues, activity), though more detail on output format could be beneficial.

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

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

Despite 0% schema coverage, the description provides clear parameter descriptions with examples (e.g., 'facebook' for owner, 'react' for repo), adding meaningful guidance beyond the raw names in the input 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 detailed statistics for a GitHub repository, listing specific metrics like stars, forks, issues, and activity. It distinguishes from sibling tools (e.g., get_repo_languages, compare_repos) by focusing on overall stats.

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

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

The description implies usage for obtaining repo stats but does not explicitly state when to use this tool versus alternatives like compare_repos or search_repos. No when-not guidance is provided.

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

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

Annotations already indicate readOnlyHint and openWorldHint, so the description adds value by detailing the return fields (name, description, stars, forks) and default behaviors (sort default 'stars', max_results default 20). This goes beyond the annotations without contradiction.

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

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

The description is compact: one line for purpose and return fields, then a structured Args section. Every sentence adds value; no redundant information.

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

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

For a search tool, the description covers query, sorting, and result limit. No output schema exists, but the return fields are listed. Could optionally mention pagination or result format, but overall sufficient for effective use.

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

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

Schema coverage is 0%, so the description carries full burden. It explains each parameter: query with example, sort with valid values and default, max_results with default. This adds critical meaning beyond the bare schema.

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

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

The description starts with '[GitHub Intelligence] Search GitHub repositories by query' which clearly states the verb 'Search' and the resource 'GitHub repositories'. It further specifies what is returned: 'repo names, descriptions, stars, forks'. This distinguishes it from siblings like 'developer-tools__search_github' by its GitHub-specific context and detailed output 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 provides a clear query format example ('machine learning python') and explains sort and max_results options with defaults. It does not explicitly state when not to use, but the context is sufficient for typical usage. The sibling list includes related tools, but the description itself doesn't offer direct comparisons.

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

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

The description adds context beyond the readOnlyHint and openWorldHint annotations by specifying the stock universe (ASX 200 + small-caps, mining juniors). However, it does not describe the return format, pagination, or any behavioral quirks like rate limits. For a screening tool, more detail on output would be beneficial.

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

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

The description is extremely concise and front-loaded: the first sentence conveys the core purpose, and the second paragraph briefly lists arguments. Every word serves a purpose with no unnecessary fluff.

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

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

The description covers the tool's purpose and parameter meanings, which is adequate for a simple screening tool. However, it lacks information about the output format or return values (no output schema). This could leave an agent uncertain about the result structure.

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

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

With 0% schema description coverage, the description compensates by explaining 'criteria' as a filter dict with examples (sector, market cap, etc.) and 'limit' as max rows. This adds meaningful semantic guidance beyond the bare schema, though it could be more exhaustive.

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 screens the Australian Securities Exchange (ASX), specifically ASX 200 and small-caps including mining juniors. This distinguishes it from other exchange-specific screeners like screen_brazil_b3, making the purpose specific and unambiguous.

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

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

The description explicitly indicates the geographic scope (Australia ASX) and the type of stocks covered. This helps an agent choose this tool over alternatives like finance__screen_stocks or other exchange screeners. However, it does not provide explicit when-not-to-use guidance or mention specific alternatives.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is clear. The description adds that the tool screens equities with filter criteria and limit, which is consistent but does not disclose additional behavioral traits like pagination or rate limits. It adds some context but not rich behavioral detail.

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

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

The description is extremely concise, with a clear front-loaded purpose and a list of arguments. Every sentence serves a purpose with zero wasted words.

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

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

Given the low complexity (2 parameters, simple screening) and presence of annotations (readOnly, openWorld), the description is mostly complete. It explains what the tool does and the parameters, but does not describe the return format or output structure. However, for a screening tool, this is generally 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 coverage is 0%, so the description compensates by explaining the criteria parameter as a filter dict with examples (sector, market cap, dividend yield) and the limit parameter as max rows. This adds meaning beyond the schema's type-only definitions, though it could be more precise about allowed keys.

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 screens Brazil's B3 exchange, specifically mentioning the Bovespa Index and Small Caps, indicating the full Brazilian universe. This provides a specific verb (screen) and resource (Brazil B3), and distinguishes it from sibling country-specific screeners.

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 for Brazilian equities through its focus on Brazil's B3 exchange. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. The context of sibling tools suggests usage, but explicit guidance is absent.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds that it screens the TSX and TSX Venture with a focus on mining/energy, but does not disclose limitations, rate limits, or other behavioral traits beyond what annotations provide.

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

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

The description is brief and well-structured: a single introductory sentence followed by bullet-style Args. Every word adds value, with no redundancy or fluff.

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

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

For a simple read-only screening tool with no output schema, the description covers the essential purpose and parameters. However, it could be more complete by stating the output format or example criteria. Given the lack of schema descriptions, the description partly compensates but not fully.

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

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

The input schema has 0% description coverage, so the description compensates by explaining 'criteria: filter dict (sector, market cap, etc.)' and 'limit: max rows to return'. This adds meaning beyond the schema types and defaults, though criteria details could be more precise.

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 screens the Toronto Stock Exchange (TSX) including TSX Composite and TSX Venture, and notes the mining/energy heavy focus. The tool name and description together distinguish it from many other exchange-specific screen tools in the sibling list.

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

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

The description does not explicitly state when to use this tool versus the many other screen tools for different exchanges. While the name indicates Canadian equities, the description lacks guidance on when not to use it 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?

Annotations already provide readOnlyHint and openWorldHint; description adds data source (Eastmoney) but no additional behavioral traits like pagination 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?

Compact and front-loaded: one line for purpose, three lines for Args with consistent format, no redundant text.

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

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

Covers purpose, parameters, and data source; but lacks return format, error behavior, or pagination details. Adequate for low complexity but not 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?

Description adds clear meaning to all 3 parameters with examples (sector: 'Banking', market_cap_min: 'in CNY', limit: default 50), compensating for 0% schema description coverage.

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

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

Clearly states 'Screen Mainland China A-shares (Shanghai + Shenzhen)' with specific verb (screen) and resource, and distinguishes from sibling screeners targeting other markets.

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

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

Implied usage via name and description; no explicit when-to-use or alternatives, but sibling names make differentiation clear.

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

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

Annotations already declare readOnlyHint and openWorldHint. The description adds no additional behavioral traits, which is acceptable but does not exceed the baseline.

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

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

The description is extremely concise: two sentences plus an args list. It front-loads the purpose and 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?

For a simple screener with 2 parameters and no output schema, the description covers the essentials. Minor gap: does not specify return format, but that is partially mitigated by annotations.

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

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

Schema description coverage is 0%, so the description compensates by explaining 'criteria' as a filter dict (sector, market cap, etc.) and 'limit' as max rows. This adds meaningful context, though the criteria parameter could be more detailed.

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 screens the Beijing Stock Exchange (BSE), China's SME board, using a specific verb 'screen' and resource. It distinguishes from sibling screeners for other exchanges.

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

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

The description implies usage when screening BSE stocks, providing clear context. However, it does not include explicit exclusions or alternative tool guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds context that it screens a specific board (ChiNext) and describes args, but does not disclose behavioral traits like pagination, rate limits, or what happens on no results. It does not contradict annotations.

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

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

The description is very short and front-loaded: first line states purpose, then two bullet points for args. No unnecessary words. However, it could benefit from slight restructuring for readability, 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 no output schema and complex criteria, the description is incomplete. It does not describe what the tool returns (e.g., list of stocks, columns), default behavior, or how to use the criteria dict effectively. The openWorldHint suggests varying results, but no further explanation.

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

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

Schema description coverage is 0%, so the description must compensate. It provides brief explanations: 'criteria: filter dict (sector, market cap, P/E, etc.)' and 'limit: max rows to return'. This adds some meaning beyond the bare schema, but the criteria structure is vague and the limit description is minimal.

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 screens ChiNext, a specific Chinese growth market, and correctly identifies it as China's Nasdaq-equivalent. The verb 'screen' and resource 'ChiNext' are explicit, distinguishing it from sibling screeners for other markets.

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

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

No guidance on when to use this tool versus alternatives. The description does not mention when to choose ChiNext over other equity screeners, nor does it provide any exclusions or prerequisites. The sibling tools are all different markets, but the description fails to contrast or specify scenarios.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds no new behavioral traits beyond the example filter, which is useful but not detailed. No mention of side effects, rate limits, or pagination.

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 clear sentences and an args list. No wasted words, and the purpose is front-loaded. Efficiency is excellent.

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

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

The tool has no output schema, and the description does not mention what the output looks like (e.g., list of stocks with fields). Given the complexity of a screener, this is a gap. The limit parameter and openWorldHint provide some context, but output structure is missing.

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

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

Schema coverage is 0%, so the description bears full burden. It explains 'criteria' as a dict of filters with a concrete example, and 'limit' as max rows. This adds meaning beyond the empty schema, though not all possible filter keys are listed.

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 screens China's STAR Market, mentioning the specific board and types (hard-tech & biotech IPOs). This distinguishes it from sibling tools for other markets like A-shares or ChiNext.

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 market-specific name and description ('Screen China's STAR Market') imply when to use this tool versus other global-equities-screener siblings. However, no explicit 'when not to use' or alternatives are given, but the context is clear enough.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=true, indicating a safe read operation. The description adds the scope (Chinese ADRs) but does not elaborate on behavioral traits beyond what annotations convey, such as data freshness or rate limits. This is adequate given the annotations.

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

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

The description is extremely concise: one line for purpose and a simple list for parameters. It front-loads the key action and resource, with no filler. Every sentence earns its place.

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

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

Given no output schema and only two parameters, the description covers the core functionality well. It could mention return format (e.g., list of stocks) but is generally sufficient for an AI to understand the tool's purpose and usage.

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

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

The schema has 0% description coverage, so the description compensates by explaining 'criteria' as a filter dict with examples (sector, market cap, P/E) and 'limit' as max rows. This adds meaningful guidance beyond the bare schema types and defaults.

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 screens Chinese ADRs listed on US exchanges, with specific examples (Alibaba, JD, PDD, NIO). It distinguishes itself from sibling tools that screen other markets, as seen in the sibling list (e.g., screen_australia_asx).

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

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

The description implies usage for Chinese ADRs by name and examples, but lacks explicit when-to-use or when-not-to-use guidance. It does not mention alternatives or contextual cues to avoid misuse, though the tool's specificity makes it somewhat obvious.

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

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

Annotations already declare readOnlyHint and openWorldHint, which cover safety and scope. The description adds that it screens specific indices but does not mention limits, pagination, or output format. It provides marginal behavioral context beyond annotations.

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

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

The description is extremely concise: a single sentence plus a two-line args list. It front-loads the market scope and provides parameter semantics with examples. 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?

The tool has simple parameters and annotations. The description covers purpose and parameter semantics moderately well. It lacks details on output structure, error handling, or usage examples, but for a screening tool these are minor gaps given the simplicity.

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

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

Despite 0% schema description coverage, the description explains criteria as 'filter dict (sector, market cap, P/E, etc.)' and limit as 'max rows to return', adding meaning beyond the schema's bare types and defaults. This gives agents useful guidance on parameter values.

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

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

Description clearly states it screens German indices (DAX 40, MDAX, SDAX, TecDAX) on Xetra/Deutsche Börse. The verb 'screen' plus the specific market and indices provides a precise purpose that distinguishes it from sibling screeners for other countries.

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 for German equities via the market name and indices. While no explicit 'when to use vs alternatives' is given, the context is clear among siblings with similarly named screeners for other markets.

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

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

Annotations already declare readOnlyHint=true, so no contradiction. The description adds useful context about the filter dictionary (e.g., industry, market cap, P/E) and the limit parameter, giving the agent a clearer understanding of capabilities beyond the annotations.

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

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

Description is extremely concise: one sentence for purpose plus two lines for arguments. All information is front-loaded and every word earns its place. No unnecessary repetition.

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

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

Tool has no output schema and the description does not specify return format (e.g., fields returned, pagination). For a screening tool with filters, this omission is significant. The description is incomplete for an agent to fully understand the tool's output.

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

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

Schema has 0% description coverage, but the description explains both parameters: 'criteria' as a filter dict with examples, and 'limit' as max rows. This adds significant meaning beyond the bare schema, though the exact format of the dict is not fully specified.

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

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

Description clearly states it screens Hong Kong-listed stocks via HKEX (Hang Seng + Mainboard + GEM), with specific verb 'screen' and resource 'Hong Kong-listed stocks'. The sibling tools are differentiated by exchange (e.g., screen_australia_asx), so this tool's purpose is unambiguous and distinct.

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

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

Description implies use for Hong Kong stocks and lists covered markets, but does not explicitly state when to use this tool versus alternatives (e.g., other screeners). However, the sibling naming convention makes the context clear, so the guidance is adequate but not explicit.

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

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

Annotations declare readOnlyHint and openWorldHint, so the description does not need to restate those. It adds context about the covered indices but does not disclose output format, pagination, or any 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 concise with only two sentences for purpose and parameter explanations. No wasted words, and the structure front-loads the core 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?

While the tool is simple and annotations cover safety, the description lacks any indication of the output format or return value. Given the absence of an output schema, this omission is noticeable.

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

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

The input schema has 0% description coverage, so the description carries the full burden. It explains that 'criteria' is a filter dict with examples (sector, market cap, P/E) and 'limit' is max rows, adding essential meaning beyond the bare schema.

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

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

Clearly states the tool screens India's NSE, listing specific indices (Nifty 50, Nifty Bank, full universe). The verb 'screen' and the resource 'India NSE' are precise, distinguishing it from sibling tools targeting other exchanges.

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 for Indian equities but does not explicitly state when to prefer this tool over other screen_* tools or alternatives. No exclusions or complementary tools are mentioned.

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

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

Annotations provide readOnlyHint=true, so the safety profile is covered. The description adds that it screens specific boards but does not disclose return format, pagination, or any side effects. With annotations, the description adds modest behavioral context.

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

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

The description is extremely concise: two lines plus a brief args list. Every sentence is necessary and front-loaded with the target market and boards. 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?

The tool is a simple screener with no output schema. The description covers purpose and parameters adequately. However, it lacks details on return format, how to construct criteria, and any limitations. For its simplicity, it is nearly complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'criteria' as a filter dict (sector, market cap, etc.) and 'limit' as max rows. This adds meaning beyond the raw schema types, though 'etc.' is vague and field names are not explicit.

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 screens the Indonesia Stock Exchange (IDX), listing specific boards (LQ45, IDX30, full Jakarta board). The verb 'Screen' is appropriate. It distinguishes from sibling tools which target other exchanges.

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

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

The description does not provide explicit when-to-use or when-not-to-use guidance. It is clear that it should be used for Indonesian equities, but no alternatives or exclusions are mentioned (e.g., vs finance__screen_stocks). The context is implicit but lacking explicit guidelines.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description need not repeat safety. The description adds that it is a screener with filter criteria, which is consistent. No additional behavioral traits (e.g., rate limits, data freshness) are disclosed, making it adequate but minimal.

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

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

The description is brief with two succinct sentences for the purpose, followed by a clear args list. It is front-loaded with the main action. Minor improvement could be more structured formatting, but overall it is efficient.

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

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

The description covers the core functionality and parameters. Since no output schema exists, the return format is not explained, but for a screener tool, the output is reasonably implied (list of stocks). The description is complete enough for an agent to use the tool correctly.

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

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

Schema coverage is 0% with criteria having no specific properties described. The description adds essential meaning by listing example filter fields (sector, market cap, P/B, dividend yield) and explaining limit as 'max rows'. This compensates for the schema's lack of detail.

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

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

The description clearly states the tool screens the Tokyo Stock Exchange, referencing specific indices (Nikkei 225, TOPIX) and market segments (Prime/Standard/Growth). This differentiates it from sibling tools focused on other exchanges.

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 tool's context is clear: it is for screening Japanese equities on TSE. However, it does not explicitly state when to avoid using this tool or suggest alternatives, leaving the decision to the agent based on sibling tool names.

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

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

Annotations already provide readOnlyHint and openWorldHint. The description adds the specific exchange context but does not disclose further behavioral traits such as data freshness, rate limits, pagination, or output format. It is consistent with annotations but adds minimal value beyond them.

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

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

The description is very concise: a purpose line and two parameter lines. Every sentence is useful, and it is front-loaded with the main action. No unnecessary words.

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

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

Given the tool's role as a stock screener with no output schema, the description explains parameters but misses critical details: what the output looks like, how to formulate complex criteria (e.g., operators, available fields), and any data source limitations. The openWorldHint suggests dynamic results but lacks specificity.

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

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

Schema description coverage is 0%, so the description compensates by explaining 'criteria' as a filter dict with examples (industry, market cap, P/E) and 'limit' as max rows. This adds meaningful context beyond the schema's bare types, though it could list more specific filter keys.

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 screens Korea's KOSPI exchange, naming example companies (Samsung, SK Hynix, etc.) and using a specific verb+resource. Among many sibling screeners for different exchanges, this differentiates by exchange and country.

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

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

The description implies usage for KOSPI stocks via the exchange name and example companies, but does not explicitly state when to use this tool versus alternatives (e.g., other exchange screeners). No when-not-to-use guidance or mention of alternatives.

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

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

Annotations already indicate readOnlyHint and openWorldHint. The description adds no behavioral context beyond stating the market, such as data freshness, pagination, or limitations.

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

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

The description is short and to the point, with no unnecessary words. The Args block is clearly separated, though formatting could be improved with bullets.

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 two parameters and no output schema, the description covers the basics but lacks details on output format or expected return values, leaving some 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?

With 0% schema description coverage, the description explains that 'criteria' is a filter dict with examples (sector, market cap) and 'limit' is max rows. This adds some value but criteria description remains vague.

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 screens Bursa Malaysia's FBM KLCI components and Main Market, using a specific verb and resource. Among sibling tools, it is distinct as the only Malaysia-specific screener.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as other market-specific screeners. No exclusions or context for selection are given.

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

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

Annotations indicate readOnly and openWorld. The description adds minimal behavioral context (e.g., no output format, pagination, or data freshness).

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

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

Short, front-loaded sentence followed by parameter list. No wasted words, though could be organized more helpfully.

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?

Lacks output structure description, critical given no output schema. Missing details on what screening results contain (e.g., fields returned).

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

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

With 0% schema description coverage, the description provides the only meaning. Clarifies limit as 'max rows' and criteria as a filter dict with examples, adding value but vague on exact keys.

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

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

Description clearly states it screens BMV equities, specifically 'IPC components and broader Mexican universe'. This verb+resource is specific and distinct from sibling tools targeting different exchanges.

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

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

No explicit when-to-use or alternatives are provided, but the country-specific name and sibling list imply usage for Mexican equities. Lacks direct 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?

The description discloses that it screens the PSEi and broader market, adding context beyond annotations (readOnlyHint, openWorldHint). However, it does not explain data freshness, real-time vs delayed, or any limitations. The behavioral context is slightly enriched but not comprehensively.

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

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

The description is brief (two lines plus a list of args) with no fluff. It front-loads the purpose and then details parameters. Slightly informal structure but efficient. Could be more structured with clearer formatting.

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 should explain return format or expected results. It does not, leaving a gap. For a low-complexity tool (2 optional params), it is adequate but not fully complete for an agent to understand what it will receive.

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

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

Schema description coverage is 0%, but the tool-level description explains 'criteria' as a filter dict with examples (sector, market cap) and 'limit' as max rows. This adds essential meaning that the bare schema lacks. It compensates well for the absence of 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 screens the Philippine Stock Exchange (PSE) and mentions PSEi components and broader market, distinguishing it from sibling screeners for other exchanges. However, 'screen' is a bit vague; it could be more specific about the action (e.g., filter/find stocks).

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

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

No explicit guidelines on when to use this tool versus alternatives. The name implies Philippines-specific screening, but there is no comparison to other global-equities-screener siblings or any 'when not to use' guidance. The usefulness must be inferred from the name alone.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds no additional behavioral context (e.g., data freshness, rate limits, or pagination). It only restates the function as a screener, which is already implied by annotations.

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

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

The description is brief and front-loaded: it states the exchange first, then provides examples, then lists parameters. No redundant or unnecessary information.

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

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

For a simple screening tool with no output schema and 2 parameters, the description covers the essential purpose and parameter meaning. However, it does not describe the return format or any limitations (e.g., pagination, max rows, data source freshness), leaving some 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?

With 0% schema description coverage, the description adds crucial meaning: it explains that 'criteria' is a filter dict (with examples like sector, market cap, dividend yield) and 'limit' is max rows. This compensates for the lack of 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 screens Saudi Arabia's Tadawul exchange and lists specific components (TASI, Aramco, banks, petrochems). It distinguishes from sibling tools that screen other exchanges by naming the specific exchange.

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 implicitly tells you to use it for Saudi Tadawul screening, and the sibling tools for other exchanges are similarly named, making the context clear. However, no explicit when-to-use or when-not-to-use guidance is provided.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, indicating a safe, read-only operation. The description adds no new behavioral traits (e.g., rate limits, data freshness, or side effects). It merely restates the scope without enhancing transparency beyond the annotations.

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

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

The description is extremely concise, with a single purpose line and two bullet-pointed parameter explanations. Every sentence adds value, and there is no redundancy or unnecessary detail. 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?

The description lacks information about the output format (e.g., list of tickers, full data rows). While the parameters are explained, the criteria dictionary's possible keys are only hinted at. For a tool with no output schema, more detail on return values would improve completeness.

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

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

The description adds meaning to the parameters by explaining that 'criteria' is a filter dict for sector, market cap, etc., and that 'limit' sets max rows. Since the schema has 0% description coverage, this is helpful but vague ('etc.'). It does not provide specific valid keys or value formats for criteria.

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

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

The description clearly states that the tool screens the Singapore Exchange (SGX) for STI components and SE-Asia REIT universe. It uses a specific verb ('Screen') and identifies the resource (SGX). However, it does not explicitly describe what the tool returns (e.g., a list of stocks with details), which slightly reduces clarity.

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 tool name and description imply it is for Singapore stocks. The sibling tools include many other country-specific screeners, so an agent can infer when to use this one. However, there is no explicit guidance on when not to use it or alternatives for different regions, leaving some ambiguity.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, which cover the behavioral safety and scope. The description adds little beyond confirming it is a screening operation, so it meets the baseline but does not enrich with extra behavioral details.

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

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

The description is extremely concise with a clear header and two-line argument list. Every word adds value, and the purpose is front-loaded. There is no redundancy.

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

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

For a simple screening tool with two optional parameters and no output schema, the description covers the core functionality and parameter meanings. It does not mention return format or error handling, but given the annotations and sibling context, it is sufficiently complete for an agent to select and invoke correctly.

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

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

With schema description coverage at 0%, the description compensates by explaining 'criteria: filter dict (sector, market cap, etc.)' and 'limit: max rows to return'. This provides meaningful semantics beyond the raw schema, though it could be more precise about valid criteria keys.

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 'Screen Johannesburg Stock Exchange (JSE)' with specific sub-sectors like Top 40, mining majors, financials. It uses the verb 'Screen' and specifies the target market, effectively distinguishing it from many sibling country-screeners.

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 for JSE stocks via the title and first sentence, but lacks explicit guidance on when not to use it or alternatives. However, the context of many sibling screeners for other markets makes the usage context clear.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, setting a strong baseline. The description adds that it focuses on specific stocks and mentions the criteria filter, which sets expectations for how the tool behaves. No contradiction.

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

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

The description is extremely concise with two clear sentences for the tool purpose and two bullet-like lines for parameters. No wasted words; front-loaded with the key purpose.

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

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

The description covers the tool's purpose, parameters, and target exchange. With no output schema, it could mention return format (e.g., list of stocks). However, the basics are covered sufficiently for a screening tool.

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

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

Schema description coverage is 0%, but the description compensates by explaining that 'criteria' is a filter dict containing fields like industry, market cap, P/E, and that 'limit' caps row count. This adds meaning beyond the bare schema.

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

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

The description clearly states the verb 'screen', the resource 'Taiwan Stock Exchange (TWSE)', and provides specific examples of stocks (TSMC, MediaTek) and sector (semiconductors heavyweights). It uniquely identifies the tool among many similar exchange-specific screeners.

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 interested in TWSE stocks, especially semiconductor heavyweights. It does not explicitly state when not to use or name alternatives, but the sibling list clearly distinguishes tools by exchange, so usage 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?

Annotations already declare readOnlyHint and openWorldHint, covering safety and variability. The description adds the scope (Thai universe and indices) but does not disclose additional behaviors like rate limits or response format. Minor value beyond annotations.

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

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

The description is extremely concise: two lines for purpose and two lines for parameters. No redundant text, front-loaded with the key action and context. Every sentence serves a clear purpose.

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

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

Given the tool's simplicity (2 parameters, no output schema), the description covers the essentials: what it screens, how to filter, and how many results. Missing return format details, but sufficient for a screener with readOnlyHint.

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

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

Schema description coverage is 0%, so the description compensates fully: it defines 'criteria' as a filter dict with examples (sector, market cap, dividend yield) and 'limit' as max rows. This adds crucial meaning beyond the raw schema types.

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 screens the Thailand Stock Exchange (SET), specifying indices SET50, SET100, and the full Thai universe. The verb 'Screen' and resource 'Thailand Stock Exchange' are precise, and the context of sibling country-specific screeners makes it distinct.

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

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

The description does not explicitly state when to use this tool versus alternatives (e.g., other country screeners). The differentiation relies on the tool name and sibling list. While implicit, it lacks clear guidance on use cases or exclusions.

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

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

Annotations provide readOnlyHint and openWorldHint, but the description adds no behavioral information beyond parameter details. No mention of auth, rate limits, or what happens with empty criteria. The description does not contradict annotations.

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

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

The description is short and front-loaded with the tool name and market. The args section is clear but could be more structured (e.g., defaults). No wasted words, but minor formatting improvements possible.

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 output schema, the description should explain the return format or behavior (e.g., what null criteria returns, pagination). It omits these details, leaving the agent uncertain about the tool's full behavior.

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

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

Schema has no descriptions (0% coverage), so the description compensates by listing 'criteria: filter dict (sector, market cap, dividend yield, etc.)' and 'limit: max rows'. This adds meaning but remains vague—criteria keys are not specified, and no format is given.

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

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

The description clearly states the tool screens Borsa Istanbul (BIST) stocks, including BIST 100, BIST 30, and the full Turkish universe. The verb 'screen' and specific market name distinguish it from sibling screeners for other markets.

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

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

The description implies usage for Turkey equity screening via the name and market mention, but no explicit guidance on when to use versus alternatives (e.g., other screeners) or when not to use it. It covers the basic context but lacks exclusion criteria.

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

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

Annotations already provide readOnlyHint and openWorldHint. The description adds context about filter criteria (sector, market cap, dividend yield) and a limit parameter, but does not cover response format, pagination, or error conditions.

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

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

The description is concise with a single sentence explaining the purpose, followed by parameter descriptions. It is front-loaded with the main action. Slight improvement could be a more structured format.

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 lacks any mention of what the tool returns (e.g., list of stocks, fields). Without an output schema, the agent has no guidance on the response structure, which is a notable gap.

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

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

Schema coverage is 0%, so the description compensates by explaining criteria as a filter dict with examples (sector, market cap, dividend yield) and limit as max rows. This adds meaning beyond the bare schema types.

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 screens the London Stock Exchange (LSE) covering FTSE 100, FTSE 250, and AIM. This specific verb+resource combination distinguishes it from other screener tools in the sibling list.

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

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

Usage is implied by the tool name and description mentioning LSE, but no explicit guidance on when to use this versus other screener tools (e.g., global-equities-screener__screen_us_finviz or finance__screen_stocks). No when-not-to-use or alternatives are mentioned.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true. The description does not contradict these, as screening is a read operation. However, it does not add significant behavioral context beyond what annotations provide, such as rate limits, pagination, or error handling. It describes input format but not deeper behavioral traits.

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

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

The description is well-structured with a clear purpose, followed by bullet-pointed args. Every sentence adds value, and there is no redundant or extraneous information. It is concise yet informative.

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

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

Given the complexity of 100+ filters and multiple input formats, the description is reasonably complete. It explains two input modes with examples. However, it omits information about return format or output structure, which would enhance completeness for a tool without an 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?

With 0% schema description coverage, the description compensates well by explaining the 'criteria' parameter can be a dict of Finviz codes, a screenerUrl, or high-level parameters, and that 'limit' controls max rows. This adds valuable meaning beyond the bare schema.

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

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

The description clearly states it screens US-listed stocks on NYSE/NASDAQ/AMEX via Finviz with 100+ filters. It distinguishes from numerous sibling tools by specifying the US market and exchange, making the purpose highly specific and unambiguous.

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

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

The description gives example input formats (Finviz filter codes, screenerUrl, high-level parameters) but does not explicitly state when to use this tool over siblings. While the US focus is implied, there is no guidance on exclusions or alternatives, leaving usage context inferred.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds no additional behavioral context (e.g., pagination, rate limits). It does not contradict annotations.

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

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

The description is concise with the purpose front-loaded and a clear args list. Every sentence is relevant, though the args section could be slightly more 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?

No output schema is provided, and the description omits return value details. For a screener tool, the output format (e.g., list of stocks with fields) is not described, leaving the agent partially uninformed.

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

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

The description explains the two parameters: criteria as a filter dict with examples (sector, market cap) and limit as max rows. This compensates for 0% schema description coverage, adding useful meaning beyond the bare schema.

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

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

The description clearly states it screens Vietnam's HOSE exchange including VN30 and full board. The name and content differentiate it from many sibling tools targeting other exchanges, though it doesn't explicitly contrast with them.

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

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

The description implies use for Vietnam stock screening but provides no guidance on when to choose this tool over other exchange-specific screeners (e.g., screen_us_finviz). No when-not-to-use or alternative recommendations are given.

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

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

The description adds value beyond annotations: it discloses the scraping behavior, output fields, and default max_results. Annotations already provide readOnlyHint (true) and openWorldHint (true). The description does not contradict annotations and explains what the tool does. However, it does not mention potential limitations like rate limits or pagination.

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

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

The description is concise and well-structured. The first sentence states the purpose, followed by a clear bullet list of arguments. Each sentence adds value with no wasted words.

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

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

Given the absence of an output schema, the description provides a complete picture of expected output and parameters. It covers the core functionality. However, it could mention error handling or result variability (though openWorldHint partially covers that). Overall, it is sufficiently complete for a lead generation 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?

With 0% schema description coverage, the description fully compensates by describing each parameter with concrete examples (e.g., 'dentist', 'Austin', 'TX') and default value for max_results. This adds crucial meaning beyond the schema's type definitions.

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

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

The description clearly states the tool's purpose: generating B2B leads by scraping Google Maps businesses with contact info. It specifies the verb 'Generate' and resource 'Google Maps businesses', and lists the output fields (names, addresses, etc.). This distinguishes it from the sibling 'search_local_businesses' which likely provides similar data but without the lead generation focus.

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 implicitly suggests use for lead generation but does not explicitly contrast with alternatives or state when not to use it. It lacks guidance on how this tool differs from 'google-maps__search_local_businesses', which is a potential alternative.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description does not add behavioral details beyond what annotations provide, such as authentication, rate limits, or what happens on errors. It does not contradict annotations.

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

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

The description is four sentences plus a concise Args section. Every sentence adds value: purpose, return fields, examples, and parameter explanation. No fluff or repetition.

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

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

For a simple search tool with three parameters and no output schema, the description covers purpose, inputs, and outputs adequately. It could mention pagination or limitations (e.g., only US locations?), but overall it is 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 description coverage is 0%, so the description must compensate. It gives example values for query and location ('plumber', 'italian restaurant', 'San Francisco, CA') and explains max_results ('Maximum results (default 20)'), adding meaning beyond the schema's type definitions.

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 'Search Google Maps for local businesses' and enumerates return fields (names, addresses, ratings, etc.), making the purpose unambiguous. It distinguishes from sibling tools like generate_leads and validate_emails by focusing on 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 example inputs for query and location but offers no guidance on when to use this tool versus alternatives (e.g., generate_leads). There is no mention of use cases, exclusions, or context where another sibling would be more appropriate.

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

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

The description adds behavioral context beyond annotations (readOnlyHint, openWorldHint) by specifying the types of checks performed: syntax, domain, and deliverability. It implies external lookups (openWorldHint) without contradicting annotations. However, it does not disclose potential failure modes or cost implications.

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

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

The description is extremely concise: two sentences and a parameter description. It is front-loaded with the purpose and uses no unnecessary words. Every sentence is informative.

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

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

For a simple tool with one parameter and no output schema, the description covers core functionality (what it validates) adequately. It could be more complete by briefly describing the return format (e.g., whether it returns a list of valid/invalid statuses), but the current level is sufficient 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?

With 0% schema description coverage, the description compensates by providing a clear definition of the `emails` parameter, including its type (list of strings) and an example. This adds meaningful guidance beyond the raw 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 validates email addresses, checking syntax, domain, and deliverability. The verb 'validate' and resource 'email addresses' are specific, and the tool is distinct from siblings which focus on other domains like search, finance, or web 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?

No guidance is given on when to use this tool versus alternatives (e.g., other validation tools). There is no mention of prerequisites, typical use cases, or scenarios where it should not be used.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=true. The description adds that the tool returns specific data fields and that all parameters are optional (defaults to empty string), which is useful context beyond the annotations.

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

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

The description is concise: a brief two-sentence overview followed by a structured parameter list. Every sentence adds value, with no extraneous text.

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

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

The description covers the purpose, parameters, and return fields, which is sufficient for a search tool. However, it does not mention pagination, result limits, or behavior when all parameters are empty, 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 0%, but the description thoroughly explains each parameter with concrete examples (e.g., 'job_title: Job title to search (e.g. 'software engineer', 'data scientist')'). This fully compensates for the lack of schema documentation.

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

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

The description clearly states the tool searches H1B visa salary data and lists the returned fields (employer, job title, salary, location, case status). It distinguishes from sibling tools like hr-compensation__search_salaries by specifying 'H1B visa' context.

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

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

The description implies use for H1B salary queries but provides no explicit guidance on when to use this tool vs alternatives such as hr-compensation__search_salaries or job-market__salary_search. No 'when-not' or alternative references are given.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=true, indicating a safe read operation with variable results. The description adds no further behavioral context (e.g., data source, update frequency). It does not contradict annotations, but adds minimal value beyond them.

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

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

The description is extremely concise: a one-line summary followed by a clean argument list. Every sentence serves a purpose 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 no output schema, the description should clarify what the returned 'salary data' includes (e.g., average, range, source). It omits output format and behavior, leaving a significant gap for a search tool.

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

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

Schema description coverage is 0%, so the description fills the gap with examples for both parameters ('product manager', 'New York'). This adds practical meaning beyond the schema's plain property names, though location could be more precisely defined.

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 general salary data for a job title and location, using a specific verb ('Search') and resource ('salary data'). It effectively distinguishes from the sibling 'hr-compensation__search_h1b_salaries' by specifying 'general', implying a different 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?

No explicit guidance on when to use this tool versus alternatives like 'hr-compensation__search_h1b_salaries' or 'job-market__salary_search'. There is no mention of prerequisites, limitations, or when not to use it.

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

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

Annotations already declare readOnlyHint=true. Description adds that it returns ratings, pros, cons, salary data, but does not disclose rate limits, authentication, or other behavioral traits. Adequate given annotations.

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

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

Two concise sentences plus parameter details. Front-loaded with purpose. No unnecessary words.

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

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

Covers purpose, parameters, and return content adequately for a simple tool. No output schema, but description lists high-level data types. Minor gap: return format not specified.

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

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

Schema has no descriptions (0% coverage). Description explains company with example 'Google' and max_results with default, adding significant 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?

Clearly states it gets Glassdoor reviews for a company, lists what it returns (ratings, pros, cons, salary data). Distinct from siblings by source and content.

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

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

No explicit when-to-use or alternatives mentioned. Agent can infer if Glassdoor reviews are needed, but no guidance on when not to use or compare with similar tools like 'job-market__salary_search'.

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

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

The description adds value by listing return fields (employer, salary, location) and is consistent with annotations readOnlyHint=true and openWorldHint=true. It does not disclose unexpected behaviors, but with annotations covering safety, 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 concise with two sentences plus parameter list. No wasted words, though the parameter list could be integrated more cleanly. 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?

For a simple tool with 2 parameters and no output schema, the description provides enough to use the tool. However, it lacks details on data source reliability, pagination, or rate limits, which would improve 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?

Despite 0% schema description coverage, the tool description provides helpful parameter explanations: job_title is the job title with an example, and location is optional with an example. This compensates well for missing 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 searches H1B visa salary data by job title and returns employer, salary, location. It distinguishes from similar tools like hr-compensation__search_h1b_salaries through the job-market prefix and focus on salary data, but could be more explicit about the data source.

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

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

No guidance on when to use this tool vs. alternatives. The description only states what it does without indicating prerequisites, exclusions, or comparisons to sibling tools like hr-compensation__search_salaries.

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 readOnlyHint and openWorldHint annotations already signal safe read and variable results. The description adds return fields but does not disclose rate limits, pagination, or data freshness limitations. Contributes moderate additional context.

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

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

The description is concise with a clear statement of purpose, return fields, and parameter explanations. No unnecessary words, 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?

The description covers parameters and return fields adequately. However, it could mention potential limitations (e.g., Indeed-specific restrictions, output format). Still fairly complete for a simple search tool without 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?

Schema coverage is 0%, so the description compensates by explaining each parameter with examples and defaults: query (required with example 'software engineer'), location (optional with example 'New York'), max_results (default 20). This provides meaning beyond the raw 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 searches Indeed for job listings and lists the returned fields (titles, companies, salaries, descriptions). This distinguishes it from sibling tools like company_reviews and salary_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 implies use for job searches but does not explicitly state when to use this tool versus alternatives like salary_search or company_reviews. No exclusions or when-not guidance provided.

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