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

No annotations are provided, so the description carries the full burden. It discloses that the tool performs a cleanup operation (potentially destructive) and returns plain text output, but lacks details on permissions, side effects, or error handling. This is minimal but adequate for a basic tool.

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

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

The description is highly concise and front-loaded, consisting of two efficient sentences that directly state the action and output without any wasted words. Every sentence adds clear value.

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

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

Given the tool's low complexity (1 optional parameter), no annotations, and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the main action and output type, though it could improve by addressing parameter usage or sibling differentiation.

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

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

The input schema has 1 parameter with 0% description coverage, and the tool description does not mention or explain the 'venv_path' parameter at all. Since there is only one parameter, the baseline is 4, but the complete lack of parameter information in the description reduces it to 3, as it fails to compensate for the schema gap.

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: cleaning the mutmut cache using the mutmut CLI or removing the .mutmut-cache file. It specifies the verb ('clean') and resource ('mutmut cache'), but does not explicitly differentiate from sibling tools like 'run_mutmut' or 'rerun_mutmut_on_survivor', which prevents a score of 5.

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 the mutmut CLI availability as a fallback, but does not specify scenarios, prerequisites, or exclusions relative to sibling tools, leaving usage context unclear.

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 behavior (filtering and ranking) and output (sorted list with reasons), but lacks details on permissions, rate limits, side effects, or error handling. For a tool with no annotation coverage, this is a significant gap in 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 front-loaded and efficient, consisting of two sentences that directly convey the tool's purpose and output without unnecessary details. Every sentence adds value, making it appropriately sized 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 (analysis and ranking), no annotations, and an output schema exists, the description is reasonably complete. It explains what the tool does and the output format, but could benefit from more behavioral context (e.g., how prioritization is determined). The presence of an output schema reduces the need to detail return values.

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

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

The input schema has 1 parameter with 0% description coverage, and the tool description does not mention any parameters. Since schema_description_coverage is low (<50%), the description does not compensate by explaining the 'venv_path' parameter. However, with 0 parameters documented in the description, the baseline is 4, but it's reduced to 3 due to the lack of any parameter information despite the schema gap.

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 with specific verbs ('prioritize', 'filtering out', 'ranking') and resources ('surviving mutants'), distinguishing it from siblings like show_survivors or show_results by emphasizing analysis rather than display. It explicitly mentions the criteria (likely materiality, log/debug-only changes, potential impact) and the output format (sorted list with reasons).

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 by mentioning 'surviving mutants', suggesting it should be used after mutation testing, but it does not explicitly state when to use this tool versus alternatives like show_survivors or rerun_mutmut_on_survivor. No exclusions or prerequisites are provided, leaving the context somewhat vague.

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 using 'mutmut CLI' and returning 'plain text output', but lacks critical behavioral details: whether this is read-only or modifies data, permission requirements, side effects (e.g., cache updates), or error handling. This is inadequate for a tool with potential mutation implications.

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

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

Two concise sentences front-load the core purpose and output. No wasted words, though it could be slightly more structured by explicitly listing parameters.

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 an output schema present, return values needn't be detailed. However, for a tool with 2 parameters (0% schema coverage) and no annotations, the description is too sparse—it doesn't clarify parameter roles, prerequisites, or behavioral risks, making it incomplete for safe agent 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 0%, so the description must compensate. It only vaguely references 'specific surviving mutations or all survivors', hinting at 'mutation_id' usage but not explaining its format or purpose. No mention of 'venv_path' at all. This leaves both parameters largely undocumented.

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 ('Rerun mutmut') and target ('on specific surviving mutations or all survivors after test updates'), distinguishing it from siblings like 'run_mutmut' (initial run) and 'show_survivors' (view only). However, it doesn't explicitly contrast with 'prioritize_survivors' (which likely organizes rather than executes).

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

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

Usage is implied by context: use after test updates to re-evaluate survivors, with 'mutation_id' for specific ones or null for all. No explicit when-not-to-use guidance or alternatives are mentioned, though it's logically distinct from 'run_mutmut' for initial runs.

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 describes what the tool does (runs mutation testing, outputs a summary or error), and adds useful context about virtual environment usage. However, it lacks details on potential side effects (e.g., file system changes), performance characteristics (e.g., runtime, resource usage), or error handling beyond a generic mention of failure.

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

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

The description is well-structured with a clear opening sentence, followed by details on parameters and returns. It avoids redundancy and stays focused, though the parameter explanations could be slightly more concise (e.g., merging some details). Every sentence adds value, and it's appropriately sized for a tool with three parameters.

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

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

Given the complexity of a mutation testing tool with no annotations, 0% schema coverage, but an output schema (implied by 'Returns'), the description is fairly complete. It covers purpose, parameters, and output behavior. However, it could better address error scenarios, prerequisites (e.g., mutmut installation), or integration with sibling tools to enhance contextual understanding.

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

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

Schema description coverage is 0%, so the description must compensate. It effectively explains all three parameters: 'target' as the module/package to test, 'options' as additional command-line arguments with an example, and 'venv_path' as an optional path for environment compatibility. This adds significant meaning beyond the bare schema, though it could provide more examples or constraints for 'options'.

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 ('run a full mutation testing session') on a specific resource ('the specified target') using a specific tool ('mutmut'). It distinguishes itself from siblings like 'clean_mutmut_cache' or 'show_results' by focusing on execution rather than cleanup or display.

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 ('initiates mutation testing on the given module or package') and mentions the optional virtual environment path for compatibility. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools, such as when to use 'rerun_mutmut_on_survivor' instead.

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 states the tool shows code diff and details, implying a read-only operation, but does not cover aspects like error handling, execution time, dependencies on mutmut, or side effects. This leaves significant gaps in understanding the tool's behavior beyond basic functionality.

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 stated first, followed by structured sections for Args and Returns. Each sentence adds value, but the formatting with bullet-like sections could be slightly more streamlined for direct 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 tool has an output schema (Returns: str), the description does not need to explain return values. It covers the purpose and parameters adequately, but with no annotations and moderate complexity (2 parameters, 1 required), it could benefit from more behavioral context to be fully complete for safe agent 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 description adds meaningful semantics for both parameters: 'mutation_id' is explained as 'The ID of the mutant to show,' and 'venv_path' as 'Path to the virtual environment, if any.' Given the schema description coverage is 0%, this compensates well by clarifying what each parameter represents, though it lacks format or example 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 tool's purpose: 'Show the code diff and details for a specific mutant using mutmut show.' It specifies the verb ('show'), resource ('mutant'), and method ('mutmut show'), but does not explicitly differentiate it from sibling tools like 'show_results' or 'show_survivors' beyond the focus on a specific mutant ID.

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 the tool's function but does not indicate scenarios for its use, prerequisites, or how it differs from siblings such as 'show_results' or 'show_survivors', leaving the agent without contextual usage cues.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the tool returns 'plain text output,' which is helpful, but lacks details on prerequisites (e.g., requires a prior mutmut run), error handling, or performance traits. It doesn't contradict annotations, but provides only basic operational context.

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

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

The description is extremely concise and front-loaded, consisting of two clear sentences that directly state the tool's function and output format without any wasted words. Every sentence earns its place by providing essential information 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?

Given the tool's low complexity (one optional parameter) and the presence of an output schema (which likely covers return values), the description is moderately complete. It explains what the tool does and the output format, but gaps remain in parameter guidance and behavioral context, making it adequate but with clear room for improvement.

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 provides no information about the 'venv_path' parameter, which has 0% schema description coverage. This leaves the parameter's purpose and usage undocumented, failing to compensate for the schema gap. The baseline would be higher if parameters were absent, but here the description adds no value beyond the schema.

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

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

The description clearly states the tool's purpose: 'Display overall results from the last mutmut run using the mutmut CLI.' It specifies the verb ('Display'), resource ('overall results'), and context ('last mutmut run'), though it doesn't explicitly differentiate from siblings like 'show_mutant' or 'show_survivors' which likely show specific subsets of results.

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

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

The description provides minimal guidance, implying usage after a mutmut run to view results, but offers no explicit when-to-use rules, exclusions, or alternatives. It doesn't clarify if this should be used instead of or alongside siblings like 'show_survivors' for different result 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?

With no annotations, the description carries full burden but provides limited behavioral insight. It mentions the output format ('plain text output'), which is helpful, but lacks details on permissions, side effects, error conditions, or rate limits. For a tool that likely reads mutation test results, more context on what 'surviving mutations' means operationally would improve 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 concise and front-loaded, stating the core purpose in the first sentence. The second sentence adds useful output format detail without redundancy. It avoids fluff, but could be slightly more structured (e.g., by explicitly mentioning the parameter).

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 (CLI-based, mutation testing context), no annotations, and an output schema, the description is minimally adequate. It covers the basic action and output format, but lacks details on prerequisites (e.g., requires a prior mutmut run), parameter use, or how it integrates with siblings. The output schema helps, but more operational context would improve completeness.

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

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

Schema description coverage is 0%, so the description must compensate, but it adds no parameter information. The single parameter 'venv_path' is undocumented in both schema and description. However, with only one optional parameter and an output schema present, the baseline is moderate. The description doesn't explain what 'venv_path' is or when to use it, leaving a gap.

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 details') and resource ('surviving mutations from the last mutmut run'), and specifies the tool uses the mutmut CLI. It distinguishes from siblings like 'show_results' or 'show_mutant' by focusing specifically on survivors. However, it doesn't explicitly contrast with all siblings, preventing 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 minimal usage guidance. It implies this should be used after a mutmut run to see survivors, but offers no explicit when-to-use rules, prerequisites, or alternatives. For example, it doesn't clarify when to use this versus 'show_results' or 'prioritize_survivors', leaving the agent to infer context.

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