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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it searches across multiple text fields, uses case-insensitive partial matching, groups results by Root Suite and Feature Suite while avoiding duplicates, and offers multiple output formats. This covers search scope, matching logic, result organization, and output options, though it doesn't mention rate limits, permissions, or error handling.

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 efficiently structured with four sentences that each add value: the core purpose, search scope and matching logic, result grouping method, and output formats. It uses emojis and formatting for readability without wasting space, and every sentence contributes essential information.

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

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

Given the tool's moderate complexity (search across multiple fields with hierarchical grouping), no annotations, and no output schema, the description does well to cover purpose, behavior, and output options. It could be more complete by mentioning what the different output formats contain or any limitations, but it provides sufficient context for an agent to understand when and how to use this tool effectively.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds some context by mentioning 'case-insensitive, partial match' for the feature_keyword parameter and listing output formats, but doesn't provide additional semantic meaning beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('Find ALL test cases related to a specific feature'), the resource ('test cases'), and scope ('across the project'). It distinguishes from siblings by specifying it searches across multiple fields (title, description, preconditions, test steps) and groups results hierarchically, unlike tools like 'get_test_case_by_title' or 'get_test_cases_by_suite_smart' which have narrower scopes.

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

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

The description provides clear context for when to use this tool: when searching for test cases related to a feature across the entire project with case-insensitive partial matching. It doesn't explicitly state when not to use it or name specific alternatives, but the context is sufficient to differentiate from siblings that filter by suite, key, or other 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions OCR and visual analysis, and that it 'returns image to Claude Vision for detailed analysis,' which gives some insight into processing behavior. However, it fails to disclose critical traits: whether this is a read-only or mutating operation, performance implications (e.g., 'slower' is noted in schema but not description), authentication needs, rate limits, or error handling. For a tool with 6 parameters and no annotations, this is a significant gap.

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

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

The description is appropriately sized and front-loaded: a single sentence efficiently conveys the core functionality (analyze screenshot with OCR/visual analysis) and key behavioral detail (returns to Claude Vision). Every word earns its place with no redundancy or fluff, making it easy to scan and understand quickly.

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

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

Given the tool's complexity (6 parameters, no output schema, no annotations), the description is moderately complete. It covers the purpose and high-level behavior but lacks details on when to use it vs. siblings, full behavioral traits, and output expectations. Without annotations or output schema, the description should do more to compensate, but it provides a basic foundation that's adequate for simple use cases.

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

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

The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema: it implies the tool uses OCR and visual analysis, which relates to 'enableOCR' and 'analysisType' parameters, but doesn't provide additional syntax, format details, or usage examples. With high schema coverage, the baseline is 3, and the description doesn't significantly enhance parameter understanding.

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

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

The description clearly states the tool's purpose: 'Analyze test screenshot with OCR and visual analysis' specifies the verb (analyze) and resource (test screenshot) with the methods used (OCR and visual analysis). It distinguishes from sibling tools like 'download_test_screenshot' (which only downloads) and 'analyze_test_execution_video' (which analyzes videos). However, it doesn't explicitly mention what makes it unique from other analysis tools in the 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 provides minimal guidance: it mentions the tool returns 'image to Claude Vision for detailed analysis,' which implies when detailed visual analysis is needed. However, it lacks explicit when-to-use criteria, doesn't specify alternatives among siblings (e.g., when to use this vs. 'analyze_test_failure'), and offers no exclusions or prerequisites. This leaves usage context largely implied.

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

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

With no annotations provided, the description carries full burden but provides minimal behavioral context. It mentions grouping by step similarity with a threshold range (80-90%), but doesn't disclose what the analysis returns, whether it's read-only or modifies data, performance characteristics, or authentication requirements. The description adds some value but leaves significant gaps.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and includes the key constraint (similarity threshold range) in parentheses. Every word earns its place.

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

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

For a 7-parameter analysis tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the analysis returns, how results are structured, whether it's a read operation, or any behavioral constraints. The description should do more to compensate for the lack of structured metadata.

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

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

Schema description coverage is 100%, so the schema fully documents all 7 parameters. The description mentions 'step similarity (80-90%)' which aligns with the 'similarity_threshold' parameter's default range, but doesn't add meaningful semantics beyond what the schema already provides. Baseline 3 is appropriate when schema does the heavy lifting.

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 ('analyze'), resource ('test cases'), and specific purpose ('for duplicates and group similar ones by step similarity (80-90%)'). It distinguishes from siblings like 'analyze_test_cases_duplicates_semantic' by specifying step-based similarity rather than semantic 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 duplicate detection with step similarity, but doesn't explicitly state when to use this tool versus alternatives like 'analyze_test_cases_duplicates_semantic' or 'aggregate_test_cases_by_feature'. 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it mentions 'advanced semantic duplicate analysis' and 'two-phase analysis,' it fails to describe critical behaviors such as computational intensity, potential rate limits, authentication requirements, or what the output looks like (e.g., clusters, insights). For a complex tool with 12 parameters, this is a significant gap.

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

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

The description is a single, efficient sentence that front-loads key information ('Advanced semantic duplicate analysis') and uses emojis and technical terms appropriately. Every word earns its place, making it highly concise and well-structured for quick comprehension.

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

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

Given the tool's complexity (12 parameters, no annotations, no output schema), the description is incomplete. It lacks details on behavioral traits, output format expectations, and usage context. While the schema covers parameters well, the description doesn't address the broader operational context needed for effective tool invocation.

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

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

Schema description coverage is 100%, so the schema already documents all 12 parameters thoroughly. The description adds no additional meaning about parameters beyond what's in the schema (e.g., it doesn't explain how 'step_clustering_threshold' interacts with 'similarity_threshold' or clarify the 'hybrid' mode). With high schema coverage, the baseline is 3, and the description doesn't compensate with extra insights.

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

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

The description clearly states the tool performs 'semantic duplicate analysis' using 'LLM-powered step clustering and two-phase analysis,' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from its sibling 'analyze_test_cases_duplicates' (which likely performs basic duplicate analysis), leaving some ambiguity about when to choose one over the other.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, compare with sibling tools like 'analyze_test_cases_duplicates,' or specify scenarios where this advanced analysis is preferred over basic methods. This leaves the agent without 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?

With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it mentions performance characteristics ('quick_text_only (no frames, ~10-20s)'), processing details ('parallel frame extraction'), and additional capabilities ('similar failures search, historical trends analysis'). However, it doesn't mention authentication requirements, rate limits, or error handling scenarios.

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 appropriately sized and front-loaded with the core purpose in the first sentence. The feature list in the second sentence is somewhat dense but relevant. Every sentence earns its place by conveying important capabilities, though the exclamation point and 'NEW' tag could be considered slightly promotional rather than purely 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 tool's complexity (16 parameters, no output schema, no annotations), the description does a good job covering the tool's scope and capabilities. It explains what the tool does, mentions analysis modes, and highlights key features. However, for such a complex tool, it could benefit from more guidance on output format or result interpretation since there's no output schema provided.

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

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

Schema description coverage is 100%, so the baseline is 3. The description doesn't add meaningful parameter semantics beyond what's already in the schema - it mentions analysis depth modes and parallel frame extraction but doesn't explain parameter interactions or provide usage examples. The schema already thoroughly documents all 16 parameters with descriptions 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's purpose: 'Download and analyze test execution video with Claude Vision - extracts frames, compares with test case, and predicts if failure is bug or test issue.' It uses specific verbs (download, analyze, extracts, compares, predicts) and distinguishes from sibling tools like analyze_screenshot or analyze_test_failure by focusing specifically on video 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 context through its feature list ('NEW: Analysis depth modes...') but doesn't explicitly state when to use this tool versus alternatives like analyze_screenshot or analyze_test_failure. It suggests video analysis is appropriate but doesn't provide guidance on prerequisites or when other tools might be better suited.

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

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

No annotations are provided, so the description carries the full burden. It mentions the tool's capabilities (logs, screenshots, error classification, similar failures, comparison) and auto-invocation from URLs, which adds useful behavioral context. However, it doesn't disclose operational traits like rate limits, authentication needs, or potential side effects (e.g., whether it triggers downloads or external AI calls). The description is informative but lacks full transparency on such behavioral aspects.

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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by new features and a usage tip. Each sentence adds value (e.g., highlighting new comparison capability and auto-invocation). It's efficient with no wasted words, though the emojis and formatting slightly reduce professionalism without harming clarity.

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

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

Given the tool's complexity (14 parameters, nested objects, no output schema) and no annotations, the description is moderately complete. It covers the purpose, key features, and a usage hint, but lacks details on output format, error handling, or prerequisites. For a forensic analysis tool with many parameters, more context on expected results or limitations would enhance completeness.

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

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

Schema description coverage is 100%, so the schema already documents all 14 parameters thoroughly. The description adds minimal parameter semantics beyond the schema—it implies analysis includes logs, screenshots, and comparisons, which aligns with parameters like 'includeLogs' and 'compareWithLastPassed', but doesn't provide additional syntax or format details. With high schema coverage, the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Deep forensic analysis of failed test including logs, screenshots, error classification, and similar failures.' It specifies the verb ('analyze') and resource ('failed test'), plus the scope of analysis. It distinguishes from siblings like 'analyze_screenshot' or 'detailed_analyze_launch_failures' by focusing on a single test's forensic details and comparison features.

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

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

The description provides clear context for when to use it: analyzing failed tests with forensic details and comparisons. It explicitly mentions auto-invocation from Zebrunner URLs, which is helpful. However, it doesn't specify when NOT to use it or name alternatives among siblings (e.g., 'detailed_analyze_launch_failures' for broader analysis), so it's not fully explicit about 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?

With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: automatic analysis limits (≤10 tests analyzed fully, otherwise first 10), pagination support, screenshot analysis impact on time, Jira smart grouping, and execution mode options affecting speed/safety. It could improve by clarifying output format details or error handling, but covers most critical aspects.

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

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

The description is front-loaded with the core purpose, but contains some redundancy (e.g., mentioning grouping/statistics/recommendations multiple times) and includes promotional elements like emojis and 'NEW' tags that don't add functional clarity. The tip about auto-invocation is useful but could be more concise. Overall, it's adequately structured but could be tighter.

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 complex tool with 12 parameters and no output schema, the description provides substantial context about behavior, limitations, and practical usage. It covers analysis scope, pagination, format options, and performance considerations. The main gap is the lack of information about return values or output structure, which would be helpful given the absence of 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?

Schema description coverage is 100%, so the baseline is 3. The description adds some value by explaining the practical implications of parameters (e.g., filterType usage, automatic analysis limits, Jira grouping), but doesn't provide significant additional semantics beyond what's already well-documented in the schema. It reinforces parameter purposes without contradicting them.

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

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

The description clearly states the tool's purpose: analyzing failed tests in a launch with grouping, statistics, and recommendations. It specifies the scope (tests without linked issues by default, with filter options) and distinguishes from siblings by mentioning unique capabilities like Jira format with smart grouping and screenshot analysis, which aren't present in other tools like 'analyze_test_failure' or 'get_launch_summary'.

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

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

The description provides clear context on when to use this tool: for analyzing failed tests in a launch, with explicit guidance on filterType options (e.g., 'without_issues' vs 'all'). It mentions auto-invocation from Zebrunner URLs as a tip. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the many sibling tools, though the unique features imply differentiation.

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

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

With no annotations provided, the description carries the full burden. It mentions authentication but doesn't specify required permissions, rate limits, or what happens if the download fails. The behavioral context is minimal for a tool that likely involves network operations and file handling.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to understand at a glance.

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

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

For a tool with 5 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the tool returns (e.g., file path, base64 data) or error handling, leaving gaps in understanding its full behavior and 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 description coverage is 100%, so the schema fully documents all parameters. The description adds no additional meaning beyond implying authentication is needed, which doesn't clarify parameter usage. Baseline 3 is appropriate as the schema handles parameter documentation.

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

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

The description clearly states the action ('Download') and resource ('test screenshot') with the platform ('Zebrunner'), and mentions authentication. However, it doesn't explicitly differentiate from sibling tools like 'analyze_screenshot', which might be for analysis rather than downloading.

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

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

No guidance is provided on when to use this tool versus alternatives like 'analyze_screenshot' or other test-related tools. The description lacks context about prerequisites or scenarios for downloading screenshots.

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

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

With no annotations provided, the description carries full burden but only mentions 'intelligent framework detection' as a behavioral trait. It doesn't disclose whether this is a read-only operation, if it modifies data, what permissions are needed, rate limits, or what the output looks like. For a code generation tool with 11 parameters, this is insufficient behavioral disclosure.

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

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

The description is a single, efficient sentence that front-loads the core purpose. The emoji adds character but doesn't detract from clarity. Every word earns its place, though it could potentially be more specific about the generation scope.

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 complex code generation tool with 11 parameters and no output schema, the description is inadequate. It doesn't explain what the generated output contains, how the framework detection works, what happens when file_path is provided, or the relationship between parameters. With no annotations and rich parameter schema, the description should provide more contextual guidance.

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

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

Schema description coverage is 100%, so the schema already documents all 11 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema, but doesn't need to compensate for gaps. The baseline 3 is appropriate when the schema does all the parameter documentation work.

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 specific action ('Generate draft test code') and resource ('from Zebrunner test case'), including the intelligent framework detection feature. It distinguishes itself from sibling tools like 'get_test_case_by_key' or 'improve_test_case' by focusing on code generation rather than retrieval or enhancement.

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 context through 'intelligent framework detection' and the tool name suggests it's for creating test drafts from existing cases. However, it lacks explicit guidance on when to use this vs. alternatives like 'improve_test_case' or 'get_test_case_by_key', and doesn't mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses behavioral traits like pagination support and API version ('new reporting API'), which is helpful. However, it doesn't mention potential rate limits, authentication requirements, error conditions, or what the output looks like (though there's no output schema). For a tool with 4 parameters and no annotations, this is a moderate but incomplete disclosure.

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

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

The description is a single, efficient sentence that front-loads the core purpose. The emoji (📋) adds visual cue but minimal informational value. No wasted words, though it could be slightly more structured (e.g., separating pagination note).

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 4 parameters, 100% schema coverage, no annotations, and no output schema, the description provides basic context but lacks depth. It mentions pagination and API version, which helps, but doesn't cover output format details, error handling, or sibling tool differentiation. For a list/retrieval tool, this is minimally adequate but leaves gaps in full agent guidance.

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

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

The schema description coverage is 100%, with all parameters well-documented in the schema itself. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain 'project' aliases or 'format' implications further). Baseline 3 is appropriate when the schema does the heavy lifting, though the description could have enhanced understanding of parameter interactions.

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

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

The description clearly states the verb ('Get all launches') and resource ('for a project'), making the purpose unambiguous. It specifies 'with pagination' and 'uses new reporting API', which adds useful context. However, it doesn't explicitly differentiate from sibling tools like 'get_all_launches_with_filter' or 'get_launch_details', missing full sibling differentiation.

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

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

The description implies usage context through 'with pagination' and 'uses new reporting API', suggesting this is for retrieving multiple launches in a paginated manner. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'get_all_launches_with_filter' or 'get_launch_details', leaving the agent to infer based on tool names alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool 'uses new reporting API' which hints at implementation details but doesn't describe critical behaviors like pagination handling (implied by page/pageSize parameters but not explained), rate limits, authentication requirements, or what happens when no filters are applied. The description is insufficient for a tool with 6 parameters and no annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the main purpose with an emoji for visual emphasis. Every element serves a purpose: the emoji indicates search/retrieval, the verb 'Get' is clear, and the parenthetical adds implementation context. However, the 'new reporting API' mention could be more specific about benefits.

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 6 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain the relationship between parameters (e.g., how 'query' interacts with 'milestone'), doesn't describe the return format or structure, and provides no error handling or behavioral context. The mention of 'new reporting API' is vague and doesn't compensate for these gaps.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value by mentioning filtering capabilities ('by milestone, build number, or launch name') which aligns with the 'milestone' and 'query' parameters, but doesn't provide additional context beyond what's in the schema descriptions. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Get launches') and specifies filtering capabilities ('with filtering by milestone, build number, or launch name'), which distinguishes it from simple listing tools. However, it doesn't explicitly differentiate from sibling tools like 'get_all_launches_for_project' or 'get_launch_details' beyond mentioning the 'new reporting API'.

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 like 'get_all_launches_for_project' or 'get_launch_details'. It mentions the 'new reporting API' but doesn't explain why this matters or when to prefer this tool over others. No exclusions or prerequisites are stated.

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

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

No annotations are provided, so the description carries full burden. It mentions pagination but doesn't disclose rate limits, authentication needs, whether it's read-only or destructive, or what happens with invalid inputs. For a tool with 6 parameters and no annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place: the emoji adds visual cue, 'Get all subsuites' states the action, 'from a root suite' specifies scope, and 'as flat list with pagination' clarifies output format and behavior.

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 operation with 6 parameters and no output schema, the description is adequate but incomplete. It covers the basic purpose and output structure but lacks behavioral details (rate limits, errors) and sibling differentiation. With no annotations and no output schema, more context would be helpful for safe invocation.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema itself. The description adds minimal value beyond implying the tool operates on a 'root suite' and produces a 'flat list', which aligns with the schema but doesn't provide additional semantic context beyond what's already in parameter descriptions.

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

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

The description clearly states the verb ('Get') and resource ('all subsuites from a root suite'), and specifies the output structure ('as flat list with pagination'). However, it doesn't differentiate from sibling tools like 'get_suite_hierarchy' or 'get_root_suites', which likely provide hierarchical or root-only views respectively.

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

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

No guidance is provided on when to use this tool versus alternatives. With siblings like 'get_suite_hierarchy' (likely hierarchical) and 'get_root_suites' (likely root-only), the description lacks explicit comparisons or context for choosing this flat-list approach over other suite retrieval methods.

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

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

With no annotations provided, the description carries full burden but only mentions 'comprehensive pagination', leaving gaps: it doesn't disclose rate limits, authentication needs, error handling, or whether this is a read-only operation. For a tool with 4 parameters and no annotations, this is insufficient 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?

Single sentence, front-loaded with key information ('Get ALL TCM test cases by project'), and uses an emoji for visual clarity. Every word earns its place with zero waste.

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 4 parameters, 100% schema coverage, no output schema, and no annotations, the description is minimally adequate. It covers the core purpose but lacks details on behavioral traits, usage context, and output expectations, leaving gaps for an AI agent to infer.

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

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

Schema description coverage is 100%, so the schema fully documents all 4 parameters. The description adds no additional parameter semantics beyond implying pagination (via 'comprehensive pagination'), which aligns with the 'max_results' parameter but doesn't provide extra syntax or format details.

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

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

The description clearly states the action ('Get ALL TCM test cases') and resource ('by project'), with 'comprehensive pagination' hinting at scope. It distinguishes from siblings like 'get_test_case_by_key' or 'get_test_cases_by_suite_smart' by emphasizing 'ALL' and project-level retrieval, though it doesn't explicitly contrast them.

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

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

No explicit guidance on when to use this tool versus alternatives like 'get_all_tcm_test_cases_with_root_suite_id' or 'get_test_cases_by_suite_smart'. The description implies it's for bulk retrieval by project, but lacks context on prerequisites, performance trade-offs, or specific use cases.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'comprehensive pagination', which hints at handling large datasets, but fails to describe critical traits like whether this is a read-only operation, potential rate limits, authentication requirements, or what the output looks like (e.g., structure, size). This leaves significant gaps for a tool that likely returns extensive data.

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

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

The description is a single, efficient sentence that front-loads the key action ('Get ALL TCM test case suites by project') and adds a useful detail ('using comprehensive pagination'). There's no wasted verbiage, though it could be slightly more structured (e.g., separating purpose from behavioral notes).

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 implied by 'ALL' and 'comprehensive pagination', and the absence of both annotations and an output schema, the description is incomplete. It doesn't address how results are returned (e.g., pagination details, response format), performance considerations, or error handling, which are crucial for an agent to use this tool effectively in a TCM 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?

The schema description coverage is 100%, so the schema already documents all parameters thoroughly (project_key, include_hierarchy, format). The description adds no additional meaning beyond what the schema provides, such as explaining the impact of 'include_hierarchy' or when to use different 'format' options. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('Get') and resource ('ALL TCM test case suites by project'), making the purpose understandable. It distinguishes itself from sibling tools like 'get_tcm_test_suites_by_project' by emphasizing 'ALL' and 'comprehensive pagination', though it doesn't explicitly name alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_tcm_test_suites_by_project' or 'get_all_subsuites'. It mentions 'comprehensive pagination' but doesn't explain when this is necessary or preferable, leaving the agent to infer 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions retrieving 'ALL' test cases but doesn't clarify scope limitations, pagination, performance implications, authentication requirements, or what 'enriched with root suite ID information' entails in practice. This leaves significant gaps for a tool that presumably handles large datasets.

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

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

The description is a single, efficient sentence with zero wasted words. It uses an emoji for visual distinction but maintains clarity. Every element ('Get ALL', 'TCM test cases', 'enriched with root suite ID information') serves a purpose.

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

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

For a tool that retrieves 'ALL' test cases with no output schema and no annotations, the description is insufficient. It doesn't address critical context like return format details (beyond the 'format' parameter), handling of large result sets, error conditions, or how the enrichment differs from basic test case data. This leaves too many unknowns 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 description coverage is 100%, so the schema already documents both parameters thoroughly. The description doesn't add any meaningful parameter semantics beyond what's in the schema (e.g., it doesn't explain why 'project_key' is required or how 'format' affects the 'enriched' output). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Get ALL TCM test cases') and specifies the enrichment ('with root suite ID information'), which is a specific verb+resource combination. However, it doesn't explicitly distinguish this tool from sibling tools like 'get_all_tcm_test_cases_by_project' or 'get_test_cases_advanced', which likely have overlapping functionality.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools for retrieving test cases (e.g., 'get_all_tcm_test_cases_by_project', 'get_test_cases_advanced'), there's no indication of what makes this tool unique or when it should be preferred over others.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the output includes 'names and IDs' but doesn't describe the return format beyond that, nor does it address authentication requirements, rate limits, error conditions, or whether this is a read-only operation. The description is minimal and leaves critical behavioral aspects unspecified for a tool with parameters.

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

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

The description is extremely concise at just one sentence with an emoji, front-loading the core purpose immediately. Every word earns its place, with no redundant information or fluff. The structure is optimal for quick comprehension while being complete enough for the stated 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 moderate complexity (2 parameters, no output schema, no annotations), the description is minimally complete. It states what the tool does but lacks context about when to use it, what the output looks like beyond 'names and IDs', or how it fits into broader workflows. For a read operation with good schema coverage, this is adequate but leaves gaps in usage guidance and behavioral transparency.

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 description coverage is 100%, with both parameters well-documented in the schema itself. The description adds no additional parameter semantics beyond what's already in the schema (e.g., it doesn't explain the relationship between project alias/key/ID or when to use each format). This meets the baseline of 3 for high schema coverage without adding value.

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

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

The description clearly states the verb 'Get' and the resource 'available priorities for a project', including the specific output 'names and IDs'. It distinguishes this tool from siblings by focusing on priorities rather than test cases, launches, or other project data. However, it doesn't explicitly differentiate from similar tools like 'get_automation_states' or 'get_project_milestones' that might also retrieve project metadata.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, timing considerations, or relationships to other tools like 'get_available_projects' (which might need to be called first) or 'get_automation_states' (which might retrieve related metadata). The agent must infer usage from the tool name and description alone.

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

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

No annotations are provided, so the description carries the full burden. It states the tool retrieves data but doesn't disclose behavioral traits like whether it's read-only, requires authentication, has rate limits, or what the output looks like (e.g., list format, pagination). This leaves significant gaps for a tool that likely interacts with project data.

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

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

The description is a single, efficient sentence with zero waste. It front-loads the purpose with an emoji for visual clarity, making it easy to scan and understand quickly without unnecessary details.

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

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

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks context on usage, behavioral traits, or output details. With no annotations or output schema, more completeness would be beneficial, but it meets a basic threshold.

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 description coverage is 100%, with clear descriptions for both parameters (project and format). The description adds no additional parameter semantics beyond what the schema provides, such as explaining the significance of automation states or output format implications. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the verb ('Get') and resource ('automation states for a project'), specifying that it retrieves names and IDs. It distinguishes from siblings like 'get_test_cases_by_automation_state' by focusing on available states rather than test cases, though it doesn't explicitly mention this 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?

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing a valid project identifier, or compare it to siblings like 'get_available_projects' or 'get_test_cases_by_automation_state' for context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'discovers' projects, implying a read-only operation, but doesn't mention critical behaviors like authentication requirements, rate limits, pagination handling (despite a parameter for pagination info), or error conditions. This is inadequate for a tool with multiple parameters and no output schema.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the core purpose and uses an emoji for visual clarity. Every part of the sentence contributes to understanding the tool's role, making it appropriately concise and well-structured.

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

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

Given the tool's complexity (4 parameters, no annotations, no output schema), the description is insufficient. It lacks details on behavioral traits, output format expectations (beyond 'keys and IDs'), and usage context. While the schema covers parameters well, the description doesn't compensate for missing annotations or output schema, leaving gaps in overall 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?

The description adds no parameter-specific information beyond what the schema provides. Since schema description coverage is 100%, the baseline score is 3. The description's mention of 'dynamic project selection' loosely relates to filtering but doesn't elaborate on parameter usage or interactions, so it doesn't enhance the schema's 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's purpose: 'Discover available projects with their keys and IDs for dynamic project selection.' It uses specific verbs ('discover') and identifies the resource ('projects') along with key output attributes ('keys and IDs'). However, it doesn't explicitly differentiate from sibling tools like 'get_project_milestones' or 'get_all_launches_for_project,' which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions 'dynamic project selection' but doesn't specify scenarios, prerequisites, or exclusions. With many sibling tools available (e.g., 'get_all_launches_for_project'), the lack of comparative context leaves the agent without clear usage direction.

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

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

No annotations are provided, so the description carries full burden. While it mentions what information is retrieved (failure summary, detailed test runs), it doesn't disclose behavioral aspects like whether this is a read-only operation, potential performance characteristics, authentication requirements, error conditions, or what happens with invalid inputs. The mention of 'SQL widgets' and templateIds provides some implementation context but not enough operational transparency.

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

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

The description is a single, efficient sentence that front-loads the core purpose. The emoji adds visual distinction but doesn't detract from clarity. While concise, it could potentially benefit from slightly more structure given the tool's complexity and lack of annotations.

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

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

For a tool with 5 parameters, no annotations, and no output schema, the description provides adequate basic purpose but leaves significant gaps. It doesn't explain what the output looks like (crucial without an output schema), doesn't cover error handling, and provides no guidance on tool selection among many similar siblings. The mention of specific templateIds (6 & 10) adds some domain context but doesn't compensate for the broader completeness 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 100% schema description coverage, the schema already documents all 5 parameters thoroughly. The description adds no parameter-specific information beyond what's in the schema - it doesn't explain relationships between parameters (e.g., how dashboardId and hashcode work together) or provide usage examples. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb ('Get') and resource ('comprehensive failure information') with specific components mentioned (failure summary, detailed test runs, SQL widgets, templateId references). It distinguishes from some siblings like 'analyze_test_failure' by emphasizing retrieval rather than analysis, but doesn't explicitly differentiate from all similar tools like 'get_launch_details' or 'get_test_execution_history'.

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. With many sibling tools dealing with test failures, launches, and bug reviews (e.g., 'analyze_test_failure', 'get_bug_review', 'get_launch_details'), there's no indication of when this specific failure information retrieval tool is preferred over other options.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions 'automatic failure detail fetching' and includes a templateId reference, it doesn't address critical behavioral aspects: whether this is a read-only operation, what permissions are required, rate limits, error handling, or what the output looks like. The SQL widget mention adds some context but doesn't fully compensate for the missing behavioral transparency.

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

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

The description is a single, efficient sentence that front-loads the core purpose. The emoji adds visual distinction but doesn't detract from clarity. The parenthetical note about templateId is somewhat technical but relevant. There's minimal waste, though it could be slightly more structured for optimal readability.

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

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

Given the complexity (8 parameters, no annotations, no output schema), the description is moderately complete. It covers the basic purpose and hints at some functionality but leaves significant gaps: no output description, no behavioral context, and no guidance on usage relative to siblings. The description alone is insufficient for an agent to fully understand how to use this tool effectively.

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

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

The schema description coverage is 100%, so the schema already documents all 8 parameters thoroughly. The description adds minimal value beyond the schema - it mentions 'failures, defects, reproduction dates' which loosely maps to output content rather than input parameters, and references 'automatic failure detail fetching' which corresponds to the 'include_failure_details' parameter. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Get detailed bug review with failures, defects, reproduction dates, and optional automatic failure detail fetching'. It specifies the verb ('Get') and resource ('bug review') with specific content details. However, it doesn't explicitly differentiate from sibling tools like 'get_bug_failure_info' or 'get_top_bugs', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions 'optional automatic failure detail fetching' but doesn't explain when this should be enabled or how this tool compares to other bug-related tools in the sibling list. There's no mention of prerequisites, 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. While it mentions 'analysis', 'validation', and 'scoring', it doesn't clarify whether this is a read-only operation, if it modifies data, what permissions are required, or what the output looks like (beyond format options). For a complex 10-parameter tool with no annotation coverage, this leaves significant behavioral gaps unaddressed.

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

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

The description is a single, efficient sentence that front-loads the core purpose. The emoji adds visual distinction without being distracting. Every word contributes to understanding the tool's enhanced nature. It could potentially benefit from a second sentence about output characteristics, but as-is it's appropriately concise for the complexity level.

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 complex 10-parameter analysis tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what 'enhanced' means relative to basic coverage tools, what 'quality scoring' entails, what rules are validated against, or what the analysis output contains. The user must infer these critical details from parameter names alone, which is inadequate for proper tool 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?

Schema description coverage is 100%, so the schema already documents all 10 parameters thoroughly with descriptions, enums, defaults, and requirements. The description adds no specific parameter information beyond what's in the schema - it doesn't explain relationships between parameters (e.g., how 'analysis_scope' affects 'validate_against_rules') or provide usage examples. The baseline 3 is appropriate when the schema does all the parameter documentation work.

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

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

The description clearly states the tool performs 'enhanced test coverage analysis with configurable rules validation and quality scoring', which is a specific verb+resource combination. It distinguishes itself from siblings like 'get_test_coverage_by_test_case_steps_by_key' by emphasizing 'enhanced' analysis with rules validation. However, it doesn't explicitly differentiate from other analysis tools like 'analyze_test_failure' or 'detailed_analyze_launch_failures' beyond the coverage 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 provides no guidance on when to use this tool versus alternatives. With many sibling tools focused on test analysis (e.g., 'analyze_test_failure', 'get_test_coverage_by_test_case_steps_by_key'), there's no indication of when this 'enhanced' analysis is preferred, what prerequisites exist, or when other tools might be more appropriate. The description assumes the user already knows the context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'enhanced authentication', which hints at potential auth requirements, but doesn't specify what those are (e.g., API keys, permissions). It also doesn't describe rate limits, error handling, pagination, or what 'comprehensive' entails beyond test sessions. For a read operation with 6 parameters and no annotations, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get comprehensive launch details including test sessions') and adds contextual notes ('uses new reporting API with enhanced authentication'). There's no wasted verbiage, and every part serves a purpose. It loses a point because the emoji (🚀) is decorative and doesn't add functional clarity.

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

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

Given the tool's complexity (6 parameters, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and hints at authentication needs, but doesn't explain output structure, error cases, or how 'comprehensive' differs from sibling tools. For a tool with moderate complexity and no structured behavioral hints, it should do more to guide 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?

The schema description coverage is 100%, meaning all parameters are documented in the schema itself. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., it doesn't explain relationships between projectKey and projectId, or clarify what 'dto' format means). Since the schema does the heavy lifting, the baseline score of 3 is appropriate—the description neither compensates for gaps nor adds extra value.

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

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

The description clearly states the tool's purpose: 'Get comprehensive launch details including test sessions'. It specifies the verb ('Get'), resource ('launch details'), and scope ('including test sessions'), which distinguishes it from simpler summary tools. However, it doesn't explicitly differentiate from sibling tools like 'get_launch_summary' or 'detailed_analyze_launch_failures', which prevents a perfect score.

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 some usage context by mentioning 'uses new reporting API with enhanced authentication', which implies this is a preferred or updated method. However, it doesn't explicitly state when to use this tool versus alternatives like 'get_launch_summary' or 'get_all_launches_for_project', nor does it specify prerequisites or exclusions. The guidance is implied rather than explicit.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'uses new reporting API' which adds some context about implementation, but doesn't describe what 'quick launch summary' contains, whether it's read-only, what permissions are needed, rate limits, or response format. For a tool with no annotation coverage, this leaves significant behavioral gaps.

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 perfectly concise - one sentence with an emoji that adds visual context. Every word earns its place: 'Get quick launch summary' states the core purpose, 'without detailed test sessions' provides important differentiation, and 'uses new reporting API' adds implementation context. 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 annotations and no output schema, the description provides adequate basic purpose but lacks important context about what the 'quick launch summary' actually contains, response format details, or behavioral constraints. For a tool with rich sibling context and no structured safety/behavior annotations, it should do more to compensate.

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

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

Schema description coverage is 100%, so the schema already documents all 4 parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. According to guidelines, when schema coverage is high (>80%), the baseline is 3 even with no param info in description.

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

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

The description clearly states the tool's purpose: 'Get quick launch summary without detailed test sessions' with the specific verb 'Get' and resource 'launch summary'. It distinguishes from siblings like 'get_launch_details' and 'get_launch_test_summary' by emphasizing 'quick' and 'without detailed test sessions'. However, it doesn't explicitly name these alternatives for full differentiation.

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

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

The description implies when to use this tool ('quick launch summary without detailed test sessions') versus more detailed alternatives, but doesn't explicitly state when-not-to-use or name specific sibling tools. It mentions 'uses new reporting API' which provides some context, but lacks explicit guidance on prerequisites or 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?

With no annotations provided, the description carries the full burden and adds valuable behavioral context: it discloses 'auto-paginated' (handling pagination automatically) and 'token-optimized' (efficient for token usage), which aren't obvious from the schema. However, it doesn't mention potential rate limits, authentication needs, or error handling.

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

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

The description is a single, efficient sentence with no wasted words, using emojis and parentheses effectively to convey key points ('lightweight', 'statistics', 'auto-paginated', 'token-optimized'). It's appropriately sized and front-loaded.

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

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

Given the complexity (12 parameters, no output schema, no annotations), the description is somewhat complete by adding behavioral context, but it lacks details on output format, error cases, or how it differs from siblings like 'get_launch_summary'. It's adequate but has clear gaps for a tool with many parameters.

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

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

Schema description coverage is 100%, so the schema already documents all 12 parameters thoroughly. The description doesn't add any parameter-specific semantics beyond what's in the schema (e.g., it doesn't explain how 'lightweight' relates to parameters like 'summaryOnly'), meeting the baseline of 3.

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

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

The description clearly states the verb ('Get') and resource ('lightweight launch test summary with statistics'), making the purpose specific and understandable. It distinguishes from some siblings like 'get_launch_details' or 'get_launch_summary' by emphasizing 'lightweight' and 'statistics', though it doesn't explicitly name alternatives.

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

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

The description implies usage through terms like 'lightweight' and 'token-optimized', suggesting it's for quick summaries rather than detailed analysis, but it doesn't provide explicit when-to-use guidance or name specific alternatives from the sibling list (e.g., 'get_launch_details' for more detailed info).

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'SQL widget' and 'templateId: 8' which gives some implementation context, but doesn't describe what type of data is returned, whether this is a read-only operation, performance characteristics, or any limitations. For a tool with 8 parameters and no annotations, this is inadequate behavioral transparency.

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

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

The description is extremely concise - a single sentence with an emoji for visual emphasis. Every element earns its place: the emoji signals reporting/analytics, the core function is stated clearly, and the SQL widget context provides implementation specificity without unnecessary elaboration.

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

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

For a tool with 8 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't explain what 'test results' actually means in terms of data structure, doesn't mention return format or typical response content, and provides minimal guidance on parameter usage despite the complex parameter set. The SQL widget reference helps but doesn't compensate for these gaps.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters thoroughly. The description adds minimal value beyond the schema - it mentions 'platform' and 'period' in the main description and references 'templateId' in parentheses, but doesn't provide additional semantic context about how parameters interact or typical usage patterns.

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

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

The description clearly states the action ('Get test results') and resource ('by platform for a given period'), with the emoji and SQL widget context adding specificity. However, it doesn't explicitly differentiate from sibling tools like 'get_all_launches_for_project' or 'get_launch_summary' that might also retrieve test data, leaving some ambiguity about its unique scope.

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

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

The description provides no guidance on when to use this tool versus alternatives among the many sibling tools. It mentions 'SQL widget, templateId: 8' which hints at a specific context, but doesn't explain when this is preferred over other test result retrieval tools or what makes it distinct in usage 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?

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Get' implies a read operation, the description doesn't address authentication requirements, rate limits, error conditions, or what the response structure looks like. The mention of 'pagination and filtering' is helpful but insufficient for a tool with 5 parameters and no output schema.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get available milestones for a project') and adds two key features ('with pagination and filtering'). Every word earns its place with zero redundancy or unnecessary elaboration.

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

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

For a tool with 5 parameters, no annotations, and no output schema, the description is insufficiently complete. While the schema documents parameters well, the description doesn't address what the tool returns, error handling, authentication needs, or how it differs from similar data retrieval tools in the sibling list. The agent would need to guess about the response format and appropriate usage contexts.

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 description coverage is 100%, with each parameter well-documented in the schema itself. The description adds minimal value beyond the schema - it mentions 'pagination and filtering' which aligns with the 'page', 'pageSize', and 'status' parameters, but doesn't provide additional context or usage examples. This meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the verb ('Get') and resource ('available milestones for a project'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'get_all_launches_for_project' or 'get_test_cases_by_filter', which follow similar patterns for different resources.

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

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

The description mentions 'pagination and filtering' which implies some usage context, but provides no explicit guidance on when to use this tool versus alternatives. With many sibling tools for retrieving project-related data (e.g., 'get_all_launches_for_project', 'get_test_cases_by_filter'), there's no indication of when milestones specifically are needed versus other project data types.

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

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

No annotations are provided, so the description carries full burden. It only states the tool's function without disclosing behavioral traits like error handling, rate limits, authentication needs, or output format details beyond the 'format' parameter. This is inadequate for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence with an emoji for emphasis. It's front-loaded with the core purpose and wastes no words, 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?

Given no annotations and no output schema, the description is minimal but covers the basic purpose. However, it lacks details on behavior, error cases, or output structure, which are important for a tool that likely returns hierarchical data. It's adequate but has clear gaps.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds no additional meaning beyond what's in the schema, such as explaining relationships between 'suite_id' and the returned root ID. Baseline 3 is appropriate when schema does all the work.

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

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

The description clearly states the action ('Get root suite ID') and target resource ('for a specific suite ID'), using an emoji for visual emphasis. It specifies the verb and resource but doesn't differentiate from sibling tools like 'get_root_suites' or 'get_suite_hierarchy', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or compare to sibling tools like 'get_root_suites' or 'get_suite_hierarchy', leaving the agent without 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation ('Get') but doesn't specify permissions, rate limits, pagination, or error handling. The description adds minimal context beyond the basic action, leaving gaps in understanding how the tool behaves in practice.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the core purpose ('Get root suites') and includes a relevant emoji for visual clarity. Every element earns its place, making it easy to scan and understand 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 read-only tool with 2 parameters and 100% schema coverage but no output schema, the description is minimally adequate. It states what the tool does but lacks details on return values, error cases, or integration with sibling tools. Without annotations or output schema, more behavioral context would improve completeness, but it meets the basic threshold.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (project_key and format). The description doesn't add any meaning beyond what the schema provides, such as explaining the significance of 'root suites' in relation to parameters. Baseline 3 is appropriate as the schema handles parameter documentation adequately.

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

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

The description clearly states the action ('Get') and resource ('root suites from project'), specifying that root suites are those with no parent. It distinguishes from siblings like 'get_all_subsuites' or 'get_suite_hierarchy' by focusing on root-level suites only. However, it doesn't explicitly contrast with these siblings in the text.

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 like 'get_all_subsuites', 'get_suite_hierarchy', or 'list_test_suites'. It lacks context about prerequisites, such as needing a valid project key, and doesn't mention any exclusions or specific scenarios where this tool is preferred.

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