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

No annotations are provided, so the description bears full responsibility. It indicates a mutation ('change') but does not disclose side effects, reversibility, permission requirements, or any impact on related entities. It also doesn't state what happens on success or failure, which is a significant gap for a state-changing operation.

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

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

The description is a single concise sentence with no wasted words, which is appropriate. However, it is so brief that it barely distinguishes itself from the tool name itself, lacking any additional structure or emphasis. Still, it is not verbose, so it earns a 4 for efficiency.

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

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

This is a mutation tool with no annotations, no output schema, and only a terse description. It does not explain the transition lifecycle, the meaning of each transition, or the expected behavior after the call. For an agent to safely invoke a state-changing operation, this is incomplete. The schema provides only parameter lists, not operational context.

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

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

The input schema covers both parameters with descriptions ('Issue key' and 'Transition to apply (confirm, falsepositive, wontfix, reopen)'), so coverage is 100%. The description adds no additional semantic context beyond what the schema already provides, hence the baseline score 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 states a specific verb ('change') and resource ('status of a SonarQube issue'), which clearly distinguishes it from sibling tools like search_issues or list_quality_gates. It is unambiguous about the tool's core function, though it doesn't mention the specific transitions, which are only in the schema.

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, no prerequisites, and no context about workflow. There is no mention of when an issue status change is appropriate or any excluded scenarios. The agent must infer entirely from the tool name and sibling list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The verb 'Get' implies a read-only retrieval, but nothing is said about permissions, pull request scoping effects, strategy behavior, unsupported metric keys, or error conditions.

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

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

The description is extremely concise with no filler or repetition. The action is front-loaded and every word earns its place, though the brevity does sacrifice contextual richness.

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

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

The tool has four parameters, a dense default metric list, no output schema, and no annotations, yet the description only offers 'Get component measures/metrics'. It says nothing about the return shape, how strategy affects results, what pullRequest does, or failure behavior, leaving too much for the 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 baseline is 3 even though the description adds no parameter-specific meaning. The schema already documents component, strategy, metricKeys, and pullRequest with descriptions and defaults, so the description does not need to compensate.

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

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

The description states a clear verb ('Get') and resource ('component measures/metrics'), so the core action is understandable. It is not a pure tautology, but it uses generic 'measures/metrics' phrasing and does not differentiate itself from overlapping siblings like search_metrics or get_quality_gate_status.

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

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

There is no guidance on when to call get_measures versus any of its siblings. The sibling list includes several metrics- and quality-related tools, but the description provides no routing hints, exclusions, or conditions that would help an agent choose correctly.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It implies a read-only list operation but does not mention pagination, ordering, authentication requirements, or what data is returned beyond the tool name.

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

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

The description is a single front-loaded sentence with no wasted words. It conveys the core action and scope immediately.

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

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

For a simple list tool with one parameter, the description is minimally adequate. However, with no output schema and no annotations, some indication of return shape, pagination, or typical usage would make it more complete for an agent.

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

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

The schema already documents the single parameter 'project' at 100% coverage. The description adds no extra semantics beyond the schema, but none are needed for this simple one-parameter tool.

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

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

The description clearly states the action ('List') and the resource ('pull requests'), and scopes it by project. It does not explicitly differentiate from sibling tools, though no sibling directly overlaps with pull requests.

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

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

No guidance is provided about when to use this tool versus alternatives, such as search_issues or get_quality_gate_status. The description gives no context about typical use cases, filtering, 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 present, so the description carries the full burden of behavioral disclosure. It only implies a read operation via 'Get' but does not explain how branch or pullRequest affect the result, what happens when optional parameters are omitted, or what status values can be returned.

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

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

The description is a single, front-loaded sentence with no filler. It states the verb, resource, and scope efficiently.

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

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

With no output schema and no annotations, the description is too thin to be complete. It omits return value shape, behavior around branch and pullRequest parameters, and any guidance on when this is the correct tool among siblings.

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 input schema already documents branch name, project key, and pull request ID. The description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Get') and names a distinct resource ('Quality Gate status') scoped to a project. It is clear enough to be distinguished from sibling list_quality_gates, though it does not explicitly contrast itself with any sibling.

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

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

The description gives no guidance on when to use this tool versus list_quality_gates, get_measures, or search_issues. There is no mention of prerequisites, branch-specific usage, or selection criteria.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys a read-like retrieval action but does not disclose behavior for missing keys, default branch resolution, precedence between branch and pullRequest, or whether the response is actually plain text versus wrapped in a structure.

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

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

The description is a single front-loaded sentence with no filler or redundant phrasing. Every word contributes to stating the core action, and no restructuring would improve 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?

With no output schema and no annotations, the description must provide more context, but it leaves key invocation details unspecified. It does not explain branch versus pullRequest semantics, how the source file is located, or what the response looks like. This is not enough for reliable agent-driven 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?

All three parameters have schema descriptions ('File key', 'Branch name', 'Pull request ID'), so the baseline is 3 even though the description adds no parameter-specific meaning. The description does not clarify how 'key' maps to a file or how branch and pullRequest interact.

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

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

The description states a specific verb ('Get') and resource ('source code as raw text'), so the tool's core purpose is immediately clear. However, it does not explicitly differentiate itself from sibling tools like get_pull_requests or get_measures, though the name itself is fairly distinctive.

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

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

No guidance is given about when to use this tool versus alternatives. It also does not explain whether branch or pullRequest should be preferred, whether they can be combined, or what happens if neither is provided. The agent is left to infer usage solely from parameter names.

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

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

No annotations exist, so the description carries the full burden. It clearly implies a read-only listing operation, but it does not disclose pagination, response format, authentication needs, or how the 'q' parameter affects results. This is adequate for a simple list tool but lacks richer behavioral context.

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

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

The description is a single front-loaded sentence with zero filler. Every word contributes meaning, making it efficient and easy to parse.

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

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

For a low-complexity tool with one optional parameter and no output schema, the description plus schema provide everything an agent needs to invoke it correctly. The scope is clear, and no critical information is missing.

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

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

Schema description coverage is 100% for the single q parameter, and the description adds no additional parameter semantics. Baseline 3 is appropriate because the schema already documents the parameter adequately.

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

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

The description states a specific action ('List') and resource ('programming languages supported'), making it immediately clear what the tool does and distinguishing it from sibling list tools such as list_projects or list_quality_gates.

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

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

There is no guidance on when to use this tool versus alternatives, no exclusions, and no mention of supported scenarios. The agent must infer usage solely from the action 'list', which provides no decision support.

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 behavioral burden. 'List projects' communicates a read-only enumeration behavior and 'in the organization' adds a scope constraint. However, it does not disclose pagination behavior, result limits, authentication needs, or what exactly is returned beyond the implication of a project list.

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, compact sentence with no wasted words. The verb, resource, and scope are all front-loaded, making it easy to parse and retain.

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

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

For a simple two-parameter list tool, the description plus full schema coverage is mostly sufficient, but without annotations or an output schema, there are gaps around return shape, pagination behavior, and any implicit access restrictions. The description is minimal and leaves room for clarification.

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

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

The schema has 100% description coverage for both parameters, so the schema already documents q and pageSize. The description adds no additional parameter meaning, which is acceptable given the baseline of 3 for full 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 states a specific verb ('List') and resource ('projects in the organization'), and the resource name clearly separates it from sibling tools like list_quality_gates and get_measures. An agent can immediately understand what this tool does.

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, and no exclusions or preference conditions. The agent must infer from the sibling names that other tools handle different resources, but the description itself offers no explicit 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?

With no annotations provided, the description must carry the full burden of behavioral disclosure, but it only states 'List all quality gates.' It does not explicitly confirm this is a read-only operation, describe the return payload, pagination, or any access requirements. The verb 'list' implies read-only, but the behavioral contract is largely implicit.

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

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

The description is a single four-word sentence that states the action and resource without any filler. It is appropriately sized for the tool's simplicity, though it sacrifices informative detail for brevity.

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

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

The tool has no output schema and no annotations, so the description should explain both the structure of the returned data and the typical use case. 'List all quality gates' only conveys the operation, not what a quality gate is, what fields are returned, or how this relates to siblings like get_quality_gate_status. An agent can invoke it, but cannot confidently predict the response or know when it is the right choice.

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 tool has zero parameters and an empty properties object, so schema coverage is effectively 100% and there are no parameters to explain. The baseline of 4 applies because no parameter semantics are needed to invoke the tool correctly.

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 specifies a clear action ('list') and a clear resource ('all quality gates'), making the primary purpose unambiguous. It indirectly differentiates from sibling get_quality_gate_status by focusing on the full collection rather than a status, but it never explicitly names any sibling or clarifies what a quality gate entails.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or sibling tools such as get_quality_gate_status or search_metrics, leaving an agent without the context needed to choose between them.

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 merely states the operation type ('List') without explaining filtering behavior, pagination, return format, or access requirements. This is a notable gap for a tool with no structured behavioral metadata.

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

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

The description is a single concise sentence with no wasted words. It is efficient and direct, though it sacrifices informational richness for brevity.

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

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

Despite the low complexity, the description is incomplete. It does not explain what rule repositories are, what the output contains, or how the optional 'q' and 'language' parameters affect the results. An agent would need to inspect the schema to infer filtering behavior, but even then output semantics remain unclear.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description does not add meaning beyond the schema, but the baseline of 3 applies because the schema is sufficient.

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

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

The description 'List rule repositories' states a specific verb and resource, making it clear what the tool does. It does not explicitly differentiate from siblings like 'show_rule' or 'list_languages', but the resource is distinct enough that purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are no mention of prerequisites, exclusions, or conditions that would help an agent choose between this and sibling list tools.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. The word 'Search' implies a read-only operation, but the description does not explicitly state that it is non-mutating, does not mention output or pagination behavior, and gives no indication of possible side effects or limitations.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to stating the tool's core purpose, making it highly concise.

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

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

Given eight parameters, no annotations, no output schema, and multiple related sibling tools, this one-sentence description is insufficient. It does not cover when to prefer this tool, what behavioral guarantees exist, or what kind of result an agent should expect.

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

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

Schema description coverage is 100%, so the parameter schema already documents all eight optional fields. The description adds no parameter-level meaning, but per the baseline for full schema coverage, a 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 identifies the action ('Search') and the resource ('issues in SonarCloud projects'), so an agent knows what the tool does. It does not differentiate this tool from siblings like list_projects or change_issue_status, but the core purpose is unambiguous.

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

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

The description provides no guidance on when to use search_issues versus alternatives such as change_issue_status or get_pull_requests. There are no exclusions, prerequisites, or context clues beyond the generic 'search' wording, so an agent has to infer usage entirely from the tool name.

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 only says 'search for available metrics' and does not mention whether the operation is read-only, what results are returned, or any other behavioral details.

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

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

The description is a single, short sentence with no filler or redundant content. It is well-structured for quick parsing, though it may be too terse to be strongly informative.

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

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

For a tool with no output schema and no annotations, the description should explain search behavior, result format, or pagination at least briefly. It only gives a vague purpose, leaving an agent without enough context to confidently invoke the tool.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds no additional parameter-level meaning beyond what the input schema provides, which aligns with 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 states a specific verb ('search') and resource ('metrics'), so an agent can identify it as a lookup tool for metrics. However, it does not clarify what 'available' means or how it differs from a plain list versus a search-with-query behavior.

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

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

There is no guidance on when to use this tool instead of sibling tools like get_measures or search_issues. The description implies a search use case but provides no exclusions, prerequisites, or alternative routing.

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 burden of behavior disclosure. 'Show' communicates a non-mutating read operation, but it doesn't specify what fields count as 'detailed', what happens for an unknown key, or the output structure. Adequate for a trivial read, but not richly transparent.

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

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

The description is a single front-loaded sentence with no filler, repetition, or tangential information. For a one-parameter lookup tool, this is appropriately minimal.

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

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

For a simple one-parameter read operation with no output schema, the description is minimally sufficient: it indicates that a rule key is needed and that detailed rule information will be returned. However, it doesn't enumerate what 'detailed information' includes or address edge cases, so it stops short of being fully self-contained.

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%, and the only parameter, key, is already documented with an example format. The description adds no additional parameter semantics, but it doesn't need to because the schema fully explains what to provide.

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

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

The description uses a concrete verb ('Show') and a specific resource ('a rule'), clearly identifying this as a single-rule read operation. It doesn't explicitly contrast with siblings like list_rule_repositories, but the singular focus on one rule's detailed information makes confusion unlikely.

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

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

The usage is implied: call this when you need detailed information about a specific rule identified by its key. It does not state exclusions or name alternative tools, but the trigger condition is reasonably inferable from the description and parameter.

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