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

No annotations are provided, and the description offers minimal behavioral context. It discloses the return value (container ID) but does not mention whether the container is started, whether the image must already exist, or any side effects such as resource allocation or network setup.

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 sentence, front-loaded with the verb and resource, and includes the key return information. No wasted words; it earns its place entirely.

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 13 parameters, no annotations, and no output schema, the description is far too sparse. It doesn't explain the creation workflow (e.g., whether the container is ephemeral, how the image is resolved, or what happens if the name exists) and provides only a minimal success signal.

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 provides thorough descriptions for all 13 parameters (100% coverage). The tool description adds no additional parameter-specific meaning, but the schema already carries the semantic load, so the baseline of 3 is appropriate.

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

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

Description clearly states the action ('Create a new WSL container') and mentions the return value (container ID). While it doesn't explicitly distinguish from container_run, the verb 'Create' and the return of an ID indicate a creation operation, making the purpose clear.

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

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

No guidance is given on when to use this tool versus alternatives like container_run or image-related tools. The description doesn't mention prerequisites (e.g., image availability) or scenarios where one might prefer container_run over container_create.

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

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

No annotations are provided, and the description only states the action without disclosing side effects, required permissions, return value format, or error behavior. For a command execution tool, 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, direct sentence that is front-loaded and contains no extraneous words. It is as concise as possible while stating the core function.

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 9 parameters, nested objects, no output schema, and no annotations. The description is too sparse to cover execution details, return values, or interaction modes (e.g., detach, tty). Full schema coverage does not compensate for missing behavioral 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 has 100% description coverage for all 9 parameters, so the description adds no additional parameter semantics. The schema itself fully documents each parameter, making the baseline of 3 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 uses specific verb 'Execute' and a clear resource 'a running WSL container'. This clearly distinguishes it from container_run, which creates new containers, and aligns with the sibling tool names.

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 phrase 'running WSL container' implies this tool is for existing containers, but there is no explicit statement about when to use it versus container_run or other alternatives. No exclusions or alternatives are mentioned, only a subtle contextual hint.

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 merely states 'Display detailed information,' which is a basic read operation, but it does not disclose any potential side effects, permissions, response format, or scope of the information returned. The transparency is minimal and lacks context beyond the tool's core action.

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 is front-loaded with the verb and object. It wastes no words and fully conveys the tool's purpose without unnecessary fluff, earning a perfect score for conciseness.

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 single-parameter inspect tool, the description is minimally complete for the purpose, but it lacks detail on what 'detailed information' includes, especially since no output schema is provided. The absence of any return or behavior details leaves a gap, though the tool's simplicity and sufficient schema keep it at an adequate level.

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

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

The input schema fully describes the sole parameter 'containerId' as 'Container ID or name,' providing 100% coverage. The description does not add any additional semantic meaning to the parameter, but the schema is sufficient on its own, aligning with the baseline score of 3 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 'Display detailed information about a WSL container,' which is a specific verb and resource. It is distinguishable from mutating container tools like container_start or container_remove, but it does not explicitly distinguish from list_containers, which also displays container information.

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 does not mention exclusions, prerequisites, or contrast with sibling tools such as list_containers or container_logs, leaving the agent to infer usage solely from the generic phrasing.

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 responsibility for disclosing behavior. It only says 'View logs' without mentioning streaming (follow), filtering by time, timestamp availability, output format, or potential large outputs. This is minimal beyond the basic read 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 sentence, highly concise, and front-loaded with the verb and object. It contains zero waste and 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?

With 6 parameters including a streaming option and time filters, the tool is quite complex, but the description provides no context about output, the effect of parameters like tail, or how follow behaves. With no output schema or annotations, this is insufficient for an agent to fully understand the tool's behavior and is below the minimum viable.

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

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

Schema coverage is 100%, with every parameter already described in the schema. The description adds no extra meaning about how the parameters behave or relate to the tool, so 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 function with a specific verb ('View') and resource ('logs from a WSL container'). It is easily distinguished from sibling tools like container_inspect or container_stats.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as for debugging output or monitoring live logs. It lacks any mention of exclusions, prerequisites, or reasons to choose this over similar container tools.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only states the action 'Remove' without mentioning irreversibility, effects on running containers, interaction with the force flag, or any safety implications.

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

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

The description is a single sentence with no wasted words, making it appropriately concise for a simple tool. However, it contributes little explanatory value, which slightly reduces the score compared to more informative concise descriptions.

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

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

Given the lack of annotations and output schema, the description is incomplete. It omits critical behavioral context such as the consequence of removing a running container, the meaning of the force flag, or whether the action is irreversible, leaving significant gaps for the agent.

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

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

Schema coverage is 100%, as both containerId and force have descriptions in the input schema. The tool description adds no additional semantic meaning beyond what the schema already provides, so the baseline 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 'Remove' and resource 'WSL container', clearly distinguishing it from sibling tools like container_stop or container_start which manage container state rather than delete it.

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 whether containers should be stopped first, when the force flag is necessary, or any prerequisites, which is significant given the force parameter.

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?

Since no annotations are provided, the description carries the full burden for behavioral disclosure. It explicitly reveals the mutating, two-phase nature of the operation ('stops then starts the container'), which signals potential disruption. It does not detail error handling or return behavior, but the core behavioral trait is clearly disclosed.

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 exceptionally concise—two sentences that front-load the main purpose and then provide essential context. Every word earns its place, with no redundancy or filler.

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

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

Given the simplicity of the operation, the description is adequately complete. It explains the tool's purpose, the reason for its existence, and the underlying mechanism. While it doesn't cover return values or edge cases, the absence of an output schema makes that less critical, and the provided context is sufficient for an agent to understand and invoke the tool correctly.

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

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

The input schema has 100% coverage with descriptive parameter explanations, so the description need not repeat them. The description adds minimal semantic value for parameters, only implying that 'time' and 'signal' relate to the stop phase. This aligns with the baseline of 3 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 function with a specific verb and resource: 'Restart a WSL container.' It also distinguishes itself from sibling commands like container_start and container_stop by explicitly noting that it executes a stop-then-start sequence due to the lack of a native restart command.

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 this tool should be used: whenever a restart is needed. It explains why it exists (no native restart in wslc) and implicitly differentiates from stop/start by positioning itself as the composite operation. However, it does not explicitly mention scenarios where one would prefer separate stop and start calls.

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

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

No annotations are provided, so the description carries the full burden. It discloses the default foreground behavior and that detach switches to background, which is useful context. However, it does not mention other side effects such as container lifecycle implications (e.g., rm removal, resource constraints, or that it may block until exit). The single behavioral trait disclosed is helpful but not comprehensive.

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

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

The description is two sentences, front-loaded with the primary action, and includes a single actionable detail (detach for background). Every sentence earns its place with no redundancy or fluff. This is an example of concise, efficient communication.

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 14 parameters, no output schema, and no annotations, the description is brief but the schema covers parameter meanings. However, it does not provide context on the overall behavior of the tool (e.g., how command and commandArgs interrelate, whether it pulls images, or what the return value indicates). Given the tool's complexity, a bit more context about the run semantics would be beneficial, but the schema fills many gaps, so a mid-range score is appropriate.

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

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

Schema coverage is 100%, with each parameter having a description. The description adds no new parameter semantics beyond reinforcing the detach parameter (already described as 'Run container in background'). The baseline is 3 because the schema does the heavy lifting; the description provides no additional meaning for parameters like env, publish, volume, etc.

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: 'Run a new WSL container.' This is a specific verb+resource combination that distinguishes from sibling tools like container_start (which starts an existing container) and container_create (which may only create without running). The mention of 'defaults to foreground' adds operational clarity. However, it does not explicitly differentiate from container_create, so a mild deduction is applied.

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 a brief operational hint about foreground vs. background ('use detach for background') but provides no guidance on when to choose this tool over alternatives like container_create or container_start. It does not mention prerequisites (e.g., image must exist or be pulled) or scenarios where one tool is preferred over another. This is minimal guidance.

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

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

No annotations are provided, so the description carries full burden for behavioral transparency. It only states the action without disclosing side effects, failure conditions (e.g., if container is already running), or state changes beyond starting. This is minimal and lacks detail.

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

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

The description is a single concise, front-loaded sentence with zero redundancy. It efficiently conveys the core action and scope, with no wasted words.

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

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

For a simple tool with fully described parameters, the description provides the basic purpose but lacks usage guidance and behavioral context. It is adequate but not thorough; no output schema exists, so return behavior is not explained, but the minimal scope of a start operation makes this acceptable.

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

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

Schema description coverage is 100%, with descriptions for 'attach', 'containerId', and 'interactive'. The tool description adds no additional parameter context, so the baseline of 3 applies; the schema sufficiently explains each parameter.

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

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

The description 'Start a stopped WSL container.' uses a specific verb ('Start') and resource ('container'), and clearly scopes to stopped containers, distinguishing it from container_run which creates a new container. This directly and unambiguously states the tool's function.

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 existing stopped containers, but does not explicitly state when to use this tool over alternatives like container_run or container_restart. No exclusions or prerequisites are mentioned, so guidance is only implicit.

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

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

With no annotations, the description must disclose behavioral traits, but it only mentions a basic read-only snapshot for running containers. It does not mention that the 'all' flag can include non-running containers, that a specific container can be targeted via containerId, or any details about output format or error behavior.

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

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

The description is a single, front-loaded sentence that conveys the core purpose with no wasted words. It is model of conciseness.

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 optional parameters and no output schema or annotations, the description is too sparse. It fails to mention the ability to show all containers or target a specific container, and does not clarify the distinction from sibling tools such as container_inspect, leaving the agent without enough context for correct 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?

The input schema provides 100% parameter description coverage, so the baseline is 3. The description adds no additional meaning beyond the schema, which already explains each parameter clearly.

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 displays resource usage snapshots for WSL containers, with a specific verb ('Display') and resource ('resource usage snapshot'). However, the qualifier 'running' is slightly misleading because the 'all' parameter can show containers regardless of status, so the scope is not fully accurate.

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 phrase 'resource usage snapshot' implies the tool is for monitoring container performance, but there is no explicit guidance on when to use it over sibling tools like list_containers or container_inspect. No exclusions or alternative recommendations are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'stop' and does not mention that the container may be forcefully killed after a timeout, how signals are handled, or that the container is not removed. This is a significant gap for a mutation 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 a single, concise sentence that is front-loaded and free of fluff. However, it is so sparse that it sacrifices detail, though it remains appropriately sized for a simple operation.

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 three parameters and no output schema, the description is too minimal. It lacks context on default behavior, side effects, and failure modes. With no annotations, this leaves the agent with insufficient information to fully understand the tool's impact.

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 descriptive names and descriptions in the schema, so the description need not add much. The tool description itself does not mention parameters, but the schema provides sufficient semantics, making the baseline 3 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 action ('Stop') and resource ('running WSL container'), which distinguishes it from sibling tools like container_start, container_restart, and container_remove. It is specific and unambiguous.

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

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

The description implies usage on running containers but does not explicitly state when to prefer this over alternatives (e.g., container_remove) or mention any prerequisites. No when-not-to-use guidance is provided.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose behavioral traits such as pulling base images, creating a new image entry, requiring network access, or producing verbose output. Side effects and failure modes are absent.

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, focused sentence without redundancy or filler. It is front-loaded with the essential purpose and leaves room for schema details to carry parameter 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?

With 9 parameters, nested objects, and no output schema, this one-sentence description is inadequate. It lacks context about build context directory, default Dockerfile behavior, expected output format, and the effect of options like noCache and buildArg. The description under-specifies a complex tool.

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

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

Schema description coverage is 100%, and all parameters are documented with descriptions. The tool description adds no extra parameter semantics beyond the schema, which already provides sufficient meaning. Baseline 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 ('Build') and identifies the resource ('container image') and source ('Dockerfile'). It clearly distinguishes from sibling tools like image_pull and image_tag by focusing on the build action.

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 prerequisites, and no exclusions. The description simply states the action without context on when it is appropriate or how it fits with other image operations.

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 via 'Display' but does not state what 'detailed information' includes, how it handles invalid image names, or whether it requires authentication. The limited transparency is a gap for a tool that could output significant 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 sentence with no redundant words. It is front-loaded and directly expresses the tool's function, making it highly concise and well-structured for its simplicity.

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 only one parameter and no output schema, a very brief description might be minimally viable. However, 'detailed information' is vague and does not clarify what specifics will be returned (e.g., config, layers, environment). For an inspect tool, this lack of detail could hinder an agent from knowing whether the output meets its needs, so the description is adequate but not complete.

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

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

The schema describes the only parameter ('image' as 'Image name or ID') with full coverage. The description adds no additional semantic value beyond the schema, but since schema coverage is 100%, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Display detailed information about a container image.' It uses a specific verb ('Display') and resource ('container image'), making it unambiguous. However, it does not explicitly distinguish itself from sibling tools like 'container_inspect' or 'list_images', so it lacks direct 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?

There is no guidance on when to use this tool versus alternatives. No exclusions, prerequisites, or mention of alternative tools are provided. The usage is only implied by the tool name and description, leaving the agent to infer appropriate contexts.

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

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

No annotations are provided, so the description must carry all behavioral disclosure. It only states the action ('pull a container image') without revealing side effects, authentication requirements, or behavior when the image already exists locally. This is minimal disclosure beyond the literal action.

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, clear sentence with no superfluous words. It earns its place efficiently, though it sacrifices depth 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?

Given the absence of annotations and output schema, the description is too sparse. It does not mention what the tool returns, potential errors, or any operational context (e.g., registry authentication). For a simple tool it is barely adequate, but significant gaps remain.

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

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

The schema provides full coverage (100%) for the single parameter 'image', including examples. The description adds no extra meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description 'Pull a container image from a registry' uses a specific verb ('pull') and resource ('container image'), clearly distinguishing it from siblings like image_push, image_build, and image_tag. The purpose is immediately obvious.

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 does not mention prerequisites (e.g., registry login) or contrast with image_push or image_build. The intended usage is only implied by the tool name and short description.

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 states the action but does not disclose auth requirements, potential side effects (e.g., overwriting existing image tags), or failure modes. This is a significant gap for a mutation 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 a single, straightforward sentence with no wordiness. It is fully front-loaded and appropriate size.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is minimally adequate. However, it lacks context about authentication needs or the relationship to registry_login, which are important for correct 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 coverage is 100%, and the schema provides a clear description and example for the image parameter. The tool description adds no additional meaning beyond schema, so the baseline 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 ('Push') and resource ('container image') with destination ('to a registry'). It clearly distinguishes from siblings like image_pull or image_build.

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 (you push an image to a registry) but provides no explicit guidance on when to use this vs. alternatives, nor prerequisites like registry_login. Context is implied rather than 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?

With no annotations provided, the description carries the full burden for behavior disclosure, but it only says 'Remove a container image.' It does not mention behaviors such as failure when the image is in use, the effect of force, or whether untagged parents are pruned.

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 that directly conveys the tool's purpose. Every word is necessary, and there is no redundant information.

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

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

For a destructive operation, the description is incomplete. It does not explain prerequisites (e.g., image must not be in use unless force is set), what happens to tagged parents, or whether the operation is reversible. The schema covers parameters but not behavioral context, and there is no output schema.

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

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

The input schema has 100% coverage for parameters, each with a clear description. The tool description adds no extra 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 clearly states the action 'Remove' and the resource 'container image', distinguishing it from sibling tools that remove containers, volumes, or networks. It is specific and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It simply states what it does, leaving the agent to infer usage.

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

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

No annotations are provided, so the description must fully disclose behavior. It only mentions tagging an image but does not explain whether this mutates the image, requires the source image to exist, or has any side effects. This leaves the agent without important 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, clear sentence that is appropriately front-loaded and contains no extraneous information. It is concise, though it could benefit from a bit more detail about 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?

Given the simplicity of the tool (2 params, no output schema), the description is somewhat adequate but incomplete. It covers the core action but omits behavioral details like whether the operation is destructive or requires authentication, which are relevant for an agent deciding to invoke it.

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 provides 100% coverage with descriptions for both parameters (source and target). The description does not add any extra semantic meaning beyond what the schema already explains, so it meets the baseline but does not improve upon it.

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

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

The description clearly states the action: 'Tag a container image with a new name/tag.' It uses a specific verb and resource, and it directly distinguishes this from sibling tools like image_pull, image_push, and image_build, which handle different operations.

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 explicit guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or scenarios where another image-related tool would be more appropriate.

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

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

No annotations are provided, so the description carries the burden. The verb "list" inherently communicates a read-only operation, and the format options are disclosed. However, the description does not explain potential edge cases (e.g., behavior with no containers, ordering, or whether WSL-specific context matters). For a list tool, this is adequate but not rich 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 two sentences and front-loaded with the primary action. Every clause earns its place: the first states the core function, the second explains the optional parameter. No filler or redundant wording.

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 simple, single-parameter tool with no required parameters and no output schema. The description sufficiently covers what the tool does and how to control the output format. Given the low complexity, it provides a complete picture; nothing critical is missing.

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

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

Schema coverage is 100% and the 'format' parameter is fully described in the schema (enum and default). The description adds only "optional" and repeats the enum values, which adds no meaning beyond the schema. Baseline 3 is appropriate because the schema handles the parameter 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 opens with a specific verb and resource: "List all WSL containers." This clearly states what the tool does and differentiates it from sibling tools like container_inspect or container_start. The mention of "WSL" adds a helpful scope qualifier, and the optional format parameter is explicitly linked to the tool's purpose.

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

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

The description implies usage by its very nature—you'd use this to list containers—but it does not explicitly contrast with alternatives (e.g., when to use this vs. container_inspect). It also doesn't mention any prerequisites or exclusions. The usage instruction for the 'format' parameter is present, but that's parameter guidance, not tool-selection guidance.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It correctly implies a read-only listing operation ('List all...') and mentions the output format options, but doesn't provide extra context like permissions, potential volume of results, or absence of side effects. This is adequate for a simple list tool but not rich.

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

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

The description is compact, containing only two sentences. It front-loads the core action and resource, then provides the optional parameter detail without any 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 that this is a simple list tool with one optional parameter and full schema coverage, the description provides sufficient context to select and invoke it correctly. The mention of 'table' and 'json' formats covers the return representation adequately, compensating for the lack 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?

The schema already fully documents the only parameter with its enum, default, and description. The description reiterates the 'format' parameter and its values, adding minimal new meaning. Since schema description coverage is 100%, a baseline score of 3 is appropriate.

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

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

The description starts with a specific verb phrase 'List all WSL container images', making the tool's purpose immediately clear. It distinguishes itself from sibling tools like list_containers and volume_list by naming the exact resource type (WSL container images).

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

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

The description explicitly mentions the optional 'format' parameter and its allowed values, giving clear guidance on output control. It doesn't explicitly name alternatives, but the resource type in the description makes selection unambiguous among list_* siblings.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Create a new WSL network,' which restates the tool's name and gives no information about side effects, default driver behavior, or interaction with containers.

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 no wasted words. However, it is so sparse that it barely adds value beyond the tool name, making it efficient in size but limited in substance.

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 create operation with multiple parameters and no output schema, the description is incomplete. It does not explain the purpose of 'opt' or 'label', when to use custom drivers, or what the command returns. Given the schema richness and sibling tools, more contextual detail is needed.

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

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

The input schema includes descriptions for all 4 parameters (name, driver, label, opt), achieving 100% schema coverage. The description adds no additional meaning beyond the schema, so it stays at 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 action (create) and resource (WSL network), and it distinguishes from sibling tools like network_remove and network_list by the verb. However, it lacks additional scope detail such as default driver or use cases.

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

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

No guidance is provided on when to use this tool versus alternatives, such as network_list for existing networks or network_remove for cleanup. The description also omits prerequisites or context like needing a running Docker daemon.

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

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

No annotations are provided, so the description must carry the full burden of disclosing behavioral traits. It only states 'List all WSL networks,' which essentially restates the name and implies a read-only operation, but it does not mention prerequisites (e.g., running Docker daemon), return format details, or potential edge cases. This is minimal and lacks depth.

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 content. Every word contributes meaning, making it highly 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?

For a simple list tool with two optional parameters and full schema coverage, the one-sentence description is adequate but leaves gaps: there is no output schema, and the description does not explain what information is included in the returned list or that the output format can be table or JSON. The format parameter hints at this, but it's not explicitly stated.

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 documents both parameters (quiet and format) with descriptive text and defaults, covering 100% of the parameter semantics. The description adds no further parameter information, 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 clearly states the function with a specific verb ('List') and resource ('all WSL networks'), which distinguishes it from sibling tools like network_create and network_remove that perform different operations on the same resource class.

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 clearly implies when to use the tool: whenever one needs to enumerate all WSL networks. It doesn't explicitly mention alternatives, but no direct alternative exists among the sibling tools for listing networks, so the context is clear without 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 must carry the full burden of behavioral disclosure. It only states 'Remove' without detailing consequences, reversibility, permission requirements, or behavior when the network is in use or does not exist. The 'force' parameter is in the schema but not described in the tool description, leaving the operational impact undocumented.

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, using a single sentence with no filler words. However, the phrase 'one or more' adds unnecessary ambiguity and could be removed without losing core meaning, slightly detracting from ideal conciseness. Overall, it is well-structured 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 absence of annotations and an output schema, the description is incomplete. It does not explain the impact of the 'force' flag, default behavior when the network is missing, or any potential side effects. A removal tool needs more context to be safely invoked, especially regarding irreversibility and error handling.

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

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

Schema description coverage is 100%, so baseline is 3. However, the description introduces 'one or more' which conflicts with the singular string 'name' parameter, creating ambiguity rather than clarity. It does not explain how multiple networks are specified, and thus adds confusion rather than meaningful semantic 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 action ('Remove') and the resource ('WSL networks'). It is specific and unambiguous about the tool's core function, distinguishing it from other tools that operate on different resources (e.g., volume_remove, container_remove). The phrase 'one or more' introduces slight ambiguity, but the core purpose is clear.

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. It does not mention prerequisites, situations where removal is appropriate or not, or any alternative tools. The description is a bare statement with no 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, the description must disclose behavior. It adds the session-default server handling and the security preference for passwordStdin, warning about credential exposure in process lists. However, it doesn't mention side effects (e.g., persisting credentials, altering local config), potential return values, or failure behavior, which are common for login tools.

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

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

Three concise, purposeful sentences. The first states the action, the second clarifies a key default, and the third gives a security recommendation. No fluff or repetition.

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

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

Given the tool's simplicity, no output schema, and no annotations, the description covers the essential behavior (login, server default, secure password handling). It lacks details on success/failure output or credential persistence, but is reasonably complete for an authentication 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?

Input schema covers all 4 parameters with descriptions, so baseline is 3. The description adds extra context about the server parameter (session default) and reinforces passwordStdin's security advantage beyond the schema text, making the parameter semantics clearer.

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: 'Log in to a container registry.' It names the specific resource type and differentiates from sibling registry_logout (which logs out) and other container/network/image tools.

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

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

The description gives clear context: it is for authenticating to a registry, with the default-server behavior explained. It implicitly recommends using passwordStdin for security, but doesn't explicitly state when to use this tool vs alternatives (e.g., registry_logout or other auth methods). No exclusions are given.

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

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

With no annotations provided, the description carries the full burden. It discloses the default-server behavior but does not mention side effects like removing stored credentials or invalidating the session. This is a partial 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 two short sentences, front-loaded with the primary action and followed by a concise clarification. 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 simple 1-parameter tool with no output schema or annotations, the description provides sufficient context to understand the action and default behavior. Missing details like credential removal are minor for a logout tool.

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

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

The schema covers 100% of the parameter semantics ('Registry server URL (default: session-defined default)'). The description repeats this with 'If no server is specified, the session default is used', adding no new information 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 uses the specific verb 'Log out' with a clear resource 'container registry', distinguishing it from sibling tools like registry_login and other management operations. It is unambiguous and immediately clear.

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 (to end an authenticated session) but does not explicitly state when to use this instead of registry_login or other tools. It provides only the server-default behavior, which is parameter-specific rather than 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, the description carries full responsibility for behavioral disclosure. It states that it removes only unused images/networks/volumes and stopped containers, which is useful. However, it does not warn about irreversibility or potential data loss, so more transparency would be appropriate.

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 sentence that efficiently conveys the action, target resources, and purpose. Every word adds value; there is no unnecessary detail.

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 parameters and no output schema, the description covers the essential behavior. It could mention typical output or confirmation prompts, but given the tool's simplicity, the current description is sufficiently complete.

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

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

There are no parameters, so the description does not need to explain any. The baseline for 0 params is 4, and the description appropriately focuses on the command's effect rather than nonexistent inputs.

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 (remove) and the exact resources affected: stopped containers, unused images, networks, and volumes. It distinguishes itself from sibling tools like container_remove or image_remove by covering all these categories at once.

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 phrase 'to free up resources' provides clear context for when to use this tool. It does not explicitly exclude other tools or mention alternatives, but the multi-resource scope makes the intended use clear.

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

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

No annotations are provided, so the description must carry the full burden. 'Get' implies a safe, read-only operation, but the description does not disclose return format, error behavior, or any side effects. For a version tool, this is minimally adequate, but it does not add extra context beyond the obvious.

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, succinct sentence that directly states the tool's function. No filler, no unnecessary details, earns every word.

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 no-parameter, no-output-schema version tool, the description is complete. It tells the agent exactly what the tool does, and there are no missing details that would affect invocation or interpretation of results.

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 the schema is empty with 100% coverage. The description does not need to elaborate on parameter semantics. The baseline score of 4 is appropriate since there is nothing to explain.

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 specific resource 'wslc CLI version information'. It is distinct from all sibling tools, which operate on containers, images, networks, volumes, and the registry, making the purpose unambiguous.

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

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

The context is clear: use this tool to retrieve CLI version information. Since there are no alternative version-related tools among siblings, no exclusions are necessary. However, it does not explicitly mention when to check version (e.g., for compatibility checks), but this is not a significant gap for such a trivial tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the operation is a creation ('Create') but does not disclose side effects, idempotency behavior, error conditions, or any permissions. The minimal description leaves the agent without context on what creating a volume might affect.

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, clear sentence with no redundant words. Every part contributes to understanding the tool's purpose, and it is properly 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 simple nature of the tool and the rich schema, the description is minimally complete. However, it lacks any mention of return value, edge cases (e.g., duplicate names), or behavior when name is omitted, which would be helpful for an agent invoking the tool. The schema covers parameters but 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?

Schema description coverage is 100%, so the schema fully describes each parameter. The description itself adds no parameter-specific meaning beyond what the schema already provides, and the baseline of 3 is appropriate.

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

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

The description uses a specific verb 'Create' with a specific resource 'new named volume' and states its purpose ('can be attached to containers'). It clearly distinguishes from sibling tools like volume_list and volume_remove, which are read/delete operations.

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 the use case by mentioning volumes are attached to containers, but it does not explicitly state when to choose this over alternatives or mention any prerequisites/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?

There are no annotations to indicate read-only or destructive nature, and the description does not disclose any behavioral attributes beyond the action itself, such as return format or side effects. The description carries the full burden and fails to elaborate on the tool's behavior.

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

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

The description is a single, direct sentence with no superfluous words, making it concise and easily parsed.

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

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

While the tool is simple, the description lacks any mention of output details or operational context. Given no output schema and no annotations, the description could be more informative, but it is minimally adequate for a straightforward list operation.

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?

Both parameters are fully described in the input schema (quiet and format), so the description adds no extra meaning. Baseline of 3 is appropriate as schema coverage is 100%.

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

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

The description uses a specific verb 'List' and a clear resource 'all WSL volumes', distinguishing it from sibling tools like volume_create and volume_remove. It also differentiates from list_containers and list_images by specifying the volume resource.

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 list_containers or volume_inspect. The description only states what it does, leaving it to 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.

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

No annotations are provided, so the description must carry the full behavioral disclosure burden. It discloses that volumes in use cannot be removed, but it does not warn that removal is permanent/destructive, mention required permissions, or describe error behavior when a volume does not exist without force. This is a significant gap for a destructive 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 consists of two short, front-loaded sentences with no fluff. Every word serves a purpose, 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 simple removal tool with full schema coverage, the description is adequate but not complete. It includes the key in-use constraint, but it lacks an explicit warning about data loss and the 'one or more volumes' wording is slightly misleading. Given the absence of annotations and output schema, a bit more caveat would make it truly complete.

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

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

Schema description coverage is 100% and already documents 'name' and 'force' adequately. The description adds no parameter-level details, and the phrase 'one or more volumes' is ambiguous given that the schema defines a single 'name' string parameter, so there is no added 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 states 'Remove one or more volumes' with a specific verb and resource, clearly distinguishing it from sibling tools like volume_create and volume_list. The added caveat about volumes in use provides scope and further clarifies the tool's 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 explicit guidance on when to use this tool versus alternatives, such as volume_list or container_remove. The in-use constraint implies a condition for failure but does not name alternatives or exclusions, leaving usage to be inferred from the purpose.

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