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

The description is transparent about the tool's behavior: it only analyzes and returns reasoning plus raw content, explicitly stating it does not generate a rewritten Dockerfile. This is a clear, non-destructive action with no hidden side effects.

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

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

The description is somewhat repetitive, repeating the 'does NOT generate the rewritten Dockerfile' point twice. It could be more concise without losing clarity, but it is well-structured and logically organized.

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 the tool has a single parameter and no output schema, the description provides sufficient context: it explains the purpose, the expected input type, the kind of output (reasoning and raw content), and how to proceed after receiving the result. The lack of an explicit output schema is mitigated by this explanation.

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

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

The sole parameter, dockerfile_path, is thoroughly explained in the description, including what it should be (an existing Dockerfile full path) and acceptable path formats (Windows, Git Bash). This adds substantial value beyond the minimal schema definition.

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 specific function: analyzing a Dockerfile to determine if it would benefit from a multi-stage build. It also highlights the detection of build-tool commands, which distinguishes it from other Dockerfile analysis tools like scanning or linting.

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 guidance on post-analysis behavior (drafting a multi-stage version yourself) and clarifies what the tool does NOT do. However, it does not explicitly state when to use this tool versus other Dockerfile analysis tools (e.g., scan_dockerfile, lint_dockerfile), leaving some ambiguity.

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

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

With no annotations, the description carries full responsibility for disclosing behavior. It mentions that the tool combines two scanners, returns a report plus raw content, and requires both trivy and hadolint to be installed. However, it does not explicitly state whether the operation is read-only or if it has any side effects, which for an audit tool is likely inferred but not stated. That minor gap prevents a perfect score.

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 and appropriately concise. It leads with the main function, then provides usage guidance, alternatives, and requirements in a logical order. Every sentence contributes value, and it does not include irrelevant details.

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

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

Given the tool's moderate complexity (two scanners, multiple parameters), the description covers all necessary aspects: purpose, usage, parameter details, and prerequisites. The existence of an output schema handles return format, so the description does not need to repeat that information. It is complete for an agent to decide when and how to use it 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 description goes beyond the schema by explaining the dockerfile_path parameter accepts both Windows and Git Bash style paths, and that severity is a comma-separated list of Trivy severities with a default of 'CRITICAL,HIGH'. This adds meaningful context that is not present in the bare schema.

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

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

The description clearly states the tool's purpose: it runs a full pre-build Dockerfile audit combining Trivy security scanning and Hadolint linting, and includes the raw Dockerfile content. It also explicitly distinguishes it from narrower tools like scan_dockerfile and lint_dockerfile, making its role 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 explicit when-to-use guidance: 'Use this for a general check/review/audit my Dockerfile request when the user hasn't specified security vs. style specifically.' It also names alternatives (scan_dockerfile, lint_dockerfile) and explains when those are more appropriate (i.e., when only one aspect is needed and a cheaper check is desired).

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 there are no annotations, the description carries the full burden of behavioral disclosure. It states the action (builds) but does not explicitly mention side effects like creating a local image, potential network access, or that it does not affect running containers. This is not misleading, but it lacks explicit transparency about the operation's side effects.

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

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

The description is concise and well-structured. The first sentence states the core purpose, followed by clarifying context about build context and path formats, then a clean listing of the two arguments. It maintains a logical flow without unnecessary repetition.

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

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

The description adequately covers the essential context for a build operation: what it does, build context behavior, and path format requirements. The output schema exists, so return values do not need to be described. While it omits details like error conditions or prerequisites (e.g., Docker daemon must be running), these are likely assumed for a Docker tool and do not severely impact completeness.

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

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

The description enriches parameter understanding beyond the schema. It explicitly describes image_tag as 'tag to give the built image' with an example, and dockerfile_path as 'full path to an existing Dockerfile' with details on accepted path formats. This adds significant semantic clarity beyond the basic type/title information in the input schema.

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

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

The description clearly states the tool's function: 'Builds a Docker image from a Dockerfile already saved on disk.' It specifies the verb (builds), resource (Docker image from Dockerfile), and scope (from a saved file). This unambiguously distinguishes it from other Docker-related tools like running containers or pulling 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 provides practical usage guidance by clarifying that the build context is the folder containing the Dockerfile and by specifying accepted path formats (Windows and Git Bash). It does not explicitly compare against alternative tools, but the purpose is clear enough that an agent can infer when to use it.

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

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

No annotations are provided, so the description carries the full burden. It discloses its limitations (does not distinguish trusted vs. untrusted networks) and advises contextual review. However, it does not explicitly state whether the operation is read-only or has side effects, though the term 'scan' suggests non-destructive behavior. This is a minor gap, so a 4 is warranted.

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 sentences and is mostly focused, but it includes a somewhat lengthy explanation of the tool's purpose and limitation. It is efficient and avoids redundancy, though a more compact phrasing could capture the same meaning with fewer words.

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

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

The description covers what the tool does (scans ports), what it flags (database/admin ports and 0.0.0.0 bindings), and its contextual limitation (may be fine on isolated hosts). Since an output schema is indicated but not shown, the description need not explain return values. Nothing essential is missing for an agent to understand when and how to use 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 tool has zero parameters and the input schema is empty (coverage 100%). There is nothing to explain about parameters, so the description fully satisfies this dimension. The absence of parameter details is not a deficiency.

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 scans running containers' published port bindings and flags known database/admin ports and any 0.0.0.0 bindings. It is specific about the action ('scans', 'flags') and the resource (containers' published ports), distinguishing it from sibling tools like list_containers or container_inspect.

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

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

The description explains what the tool is meant to catch (services reachable from the network) but does not explicitly state when to use it versus alternatives. It implies a security review context, but there is no direct comparison to sibling tools like scan_image or audit_dockerfile, 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?

Annotations are absent, so the description carries full responsibility for disclosing behavior. It mentions secret redaction, which is a useful behavioral detail, but it does not disclose that executing commands can have side effects on the container or host, whether the command runs with elevated privileges, or any failure modes. For a tool that executes arbitrary shell commands, this lack of cautionary information 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 exceptionally concise, with a single purpose sentence followed by a two-item argument list. Every word earns its place: it states the action, the secret-redaction behavior, and the parameter meanings in a compact format. It is front-loaded with the core purpose and avoids any redundant phrasing.

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

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

The tool is simple with only two parameters, both documented in the description. It has an output schema, so return-value details are not required. The description covers the core purpose, the prerequisite that the container must be running, and the redaction behavior. It does not mention edge cases like command timeouts or environment variables, but given the tool's simplicity and the presence of an output schema, it is sufficiently complete for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It does so effectively: it states 'container_name: Docker Container name' and 'command: shell command to run inside the container, e.g. "ls -la /app"'. This adds meaning beyond the raw schema names and provides a concrete example for the command parameter. The only minor miss is not elaborating on the output format, but that is covered by the output 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 a specific action: 'Executes a shell command inside a running container and returns its output.' It identifies the resource (a running container), the action (executing a shell command), and the outcome (returning output). This distinguishes it from siblings like container_logs (which retrieves logs) and container_inspect (which inspects configuration), so an agent can immediately understand its unique role.

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

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

The description implies usage context by specifying 'inside a running container,' but it does not explicitly state when to prefer this tool over alternatives or mention exclusions. There is no reference to sibling tools for comparison, leaving the agent to infer that this is for arbitrary command execution. It provides clear context but lacks explicit when/when-not guidance, so it falls at the baseline for this dimension.

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 behavioral transparency burden. It does disclose a non-obvious behavior (redacting secret environment variable values) and 'returns' implies a read operation, but it omits error conditions and any side-effect statement beyond the implied read-only nature.

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 concise sentences with no filler. The main purpose is front-loaded and the redaction caveat is placed second, making the structure clear and scannable.

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

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

For a simple one-parameter inspect tool, the description provides enough context: it states what data is returned, mentions the redaction behavior, and names the required input. It does not need to restate output schema details because an output schema exists.

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 no description for container_name, and the description only repeats 'Docker Container name'. It does not clarify whether an ID is accepted, whether the match is exact, or what happens if the container is not found, so it adds minimal meaning beyond the parameter name.

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

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

The description clearly identifies the tool's purpose with the verb 'returns' and the resource 'container', and enumerates the specific kinds of information returned (environment variables, mounts, network IP, health status). This distinguishes it from sibling tools such as container_logs 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?

There is no guidance about when to use this tool instead of the many sibling tools. It does not mention use cases, prerequisites, or explicit alternatives.

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

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

The description mentions that secret-like values are redacted, which is a useful behavioral note. However, it does not explicitly state that the operation is read-only or describe any potential side effects, relying on the implied 'collect and display' nature.

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, containing only essential information about the action, secret redaction, and parameter meanings. No redundant or verbose content is present.

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

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

The description provides necessary context for a basic logs tool, including secret redaction and the default tail value. It does not describe the output format or edge cases, but for a straightforward logs retrieval, it 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?

Both parameters (container_name and tail) are described in the description text. Container name is identified as the target, and tail is clarified as the number of lines with a default of 200. This fully covers the input schema.

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

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

The description clearly states the verb 'collect and display' and the resource 'logs for a container'. It is distinct from sibling tools like container_inspect or container_stats, 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?

No guidance is provided on when to use this tool versus alternatives such as stack_logs or container_inspect. An agent would need to infer the appropriate context from the tool name alone.

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

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

There are no annotations and the description gives no insight into side effects, such as whether the container's state is preserved, whether it performs a graceful shutdown, or whether it forces a restart. The user is left completely in the dark about 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 extremely concise, which is positive, but it is so brief that it omits critical information. It is a single sentence with no structure or additional context, making it efficient yet insufficient.

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 rich set of sibling tools (start, stop, inspect, logs, etc.), this description fails to place restart in context. It does not explain what happens to running processes, how it interacts with container state, or what output might be expected. Despite having an output schema, it is not described.

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 only parameter, container_name, is listed in the schema but the description adds no additional meaning—no format, no examples, no constraints, and no indication of whether it must be an ID or a name. Schema coverage is 0%, so the description must compensate but does not.

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

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

The description states a clear verb ('Restarting') and resource ('a container'), but does not clarify what restarting entails (stop then start) or how it differs from sibling tools like container_start or stop_container. It is understandable but lacks sufficient 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?

No guidance is provided on when to use this tool versus alternatives such as container_start, stop_container, or container_exec. The description does not mention scenarios where restart is preferred or any prerequisites (e.g., container must already exist).

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, and the description does not disclose side effects, state changes, idempotency, error behavior, or permissions. Starting a container is a state-changing operation, but the description only states the action without explaining consequences.

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 contains no unnecessary words or redundant content. The structure is clear and easy to parse.

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

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

The description is too sparse to be considered complete for an agent. It omits behavioral details, error conditions, return expectations, and any relationship to sibling tools, leaving the agent to infer important context.

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

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

The schema has one parameter with no description coverage, but the tool description includes an Args line: 'container_name: name to start the container.' This minimally compensates for the schema gap, though it lacks detail about format, constraints, or validation.

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 and resource: 'Starting a container.' It distinguishes this tool from sibling tools like container_stop and container_restart, though it does not explicitly mention Docker or context.

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

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

The description provides no guidance on when to use this tool versus alternatives such as run_container or deploy_stack. It does not explain prerequisites, when starting is appropriate, or how it differs from related 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, the description carries the full burden of signaling behavior. The word 'Shows' implies a read-only operation, but the description does not explicitly state that no state is modified, nor does it mention potential failure modes (e.g., container not running) or permission requirements. It is accurate but lacks explicit transparency.

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

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

The description is extremely concise, consisting of two short sentences. It states the purpose and the argument with no extraneous words. The structure is clean 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 read-only tool with a single parameter, the description is adequately complete. It tells the user what the tool does and what input it needs. It does not describe the output format (e.g., JSON metrics), but this is not strictly required for a tool of this simplicity, and the sibling context suggests a standard metrics output.

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

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

The only parameter, container_name, is described as 'Docker Container name,' which matches the schema title. This is clear for a simple identifier, but the description adds no additional context (e.g., format, name vs. ID, or that the container must exist). It does not go beyond the schema's minimal information.

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: 'Shows live CPU and memory usage for a running container.' It uses the specific verb 'Shows' and identifies the resource (CPU/memory usage) and target (running container), distinguishing it from sibling tools that handle logs, inspection, or execution.

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, for example, that it is preferable to container_inspect for live metrics, or that it requires a running container. Users are left to infer usage context from the description alone.

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

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

No annotations are present, and the description only states 'Creates,' implying a mutating operation. It does not disclose side effects like potential conflicts (e.g., duplicate network names), required permissions, or idempotency 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 extremely concise, consisting of a single sentence and parameter descriptions. No unnecessary words or 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?

The description does not mention what the tool returns after creation (e.g., network ID, success message). While not always critical for a creation tool, the absence of output expectations leaves some ambiguity for the agent.

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

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

The description covers both parameters: network_name and driver, with driver providing example values ('bridge', 'overlay', 'macvlan'). This adds context beyond the schema defaults, giving the agent sufficient understanding of parameter usage.

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 explicitly states the tool's function: 'Creates a new Docker network.' This clearly distinguishes it from sibling tools like list_networks and create_volume.

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 network creation but does not explicitly compare with alternatives or provide conditions for when to use this tool over others. Basic guidance is sufficient for a simple creation action.

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

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

The description indicates a creation side effect but remains silent on important behaviors such as idempotency (error if volume exists), permission requirements, or any other consequences. With no annotations providing extra safety context, the sparse description leaves significant behavioral ambiguity.

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

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

The description is very concise and front-loaded with the core action. It avoids unnecessary wording, though it could be slightly more informative without bloating.

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 likely returns a confirmation or volume object, but no output details are provided despite an output schema being indicated. Missing error scenarios, timeout behavior, or relationship to other Docker operations leaves the description incomplete for full autonomous 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 includes a brief inline explanation for each parameter (volume_name and driver) and notes the default for driver. However, the explanations are shallow and do not elaborate on validation, constraints, or special values.

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

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

The description clearly states the action ('Creates') and the resource ('Docker volume'), making the purpose unambiguous. It does not explicitly differentiate from other volume-related tools but the verb-object structure is sufficient.

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 regarding when to use this tool compared to alternatives like list_volumes, remove_volume, or create_network. The description offers no contextual decision-making information.

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 discloses the stop-before-delete behavior, destructive/irreversible nature, and the two-phase confirmation flow — all beyond what the schema implies. This is strong 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: three core sentences plus parameter explanations. The most critical safety note (destructive, preview first) is front-loaded, and every sentence adds value without redundancy.

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

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

The description covers the key behaviors, safety mechanism, and parameters. An output schema exists, so return values are likely defined elsewhere. It does not mention prerequisites like container existence or permissions, but for a container deletion with a confirmation flag, this is adequate.

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

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

Schema coverage is 0%, so the description must compensate. It explicitly explains both parameters: container_name is the name to delete, and confirm must be True to actually delete (default False). No ambiguity remains.

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 (delete), resource (container), and the specific condition (stops it first if running). It distinguishes from sibling tools like stop_container (which only stops) and container_restart, and flags it as destructive and irreversible.

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?

It gives explicit guidance on when to use confirm=True vs False, emphasizing that the default previews and only explicit user consent triggers deletion. It does not name alternative tools (e.g., stop_container) for the 'just stop' case, but the context is clear enough to infer.

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

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

With no annotations provided, the description carries full responsibility and does well by stating the operation is destructive, irreversible, and that the default confirm=False performs no deletion. This clearly sets expectations about side effects.

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

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

The description is compact and well-structured, using short paragraphs and bullet-like Args entries. Every sentence adds necessary information about behavior or parameters, with no fluff.

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

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

It covers the destructive nature, the preview mode, and the explicit confirmation requirement, which is the critical context for this tool. The presence of an output schema mitigates the lack of return-value details, so the 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?

The Args section explains image_name as the image to be deleted and confirm as the flag that must be True to perform deletion, defaulting to False. This adds meaningful semantics beyond the bare schema, though image_name format is not detailed.

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

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

The description clearly states the tool deletes a Docker image by tag or ID, and highlights the force behavior with stopped containers. This distinguishes it from sibling tools like delete_container and list_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?

It explicitly explains the two-phase confirm flow: confirm=False previews, confirm=True actually deletes, and only after explicit user agreement. It does not compare against alternative tools, but it gives clear operational guidance for safe 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?

There are no annotations, so the description carries full responsibility for disclosing side effects. It only says 'deploys' but does not explain what happens to an existing stack with the same project name, whether resources are created or modified, or what state changes occur.

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

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

The description is concise and well-structured, with a clear one-sentence purpose followed by succinct parameter explanations. No redundant or irrelevant information is present.

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 two-parameter tool, the description covers the core invocation details and the purpose of each parameter. It could mention expected output or side effects, but the provided information is mostly sufficient for basic usage.

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

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

The schema only provides type and required status, while the description adds meaningful semantics for both parameters: project_name is a unique grouping identifier, and compose_yaml must contain the full docker-compose.yml contents. This fully covers the parameters.

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 action: deploying a multi-container application from a docker-compose YAML definition. It identifies the specific resource and scope without ambiguity.

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

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

The description implies usage when deploying a Compose-based stack, but it does not explicitly explain when to prefer this tool over sibling tools such as run_container, stack_status, or remove_stack. No direct alternatives or exclusions are mentioned.

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

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

With no annotations provided, the description carries the full transparency burden. It explicitly says 'scans' and 'reports,' implying a read-only operation, and mentions the return of a clean-bill-of-health message. However, it does not directly state that the tool makes no modifications to containers, which would be clearer for a diagnostic 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 two concise sentences that front-load the purpose and then summarize the return behavior. The format is clean, with no irrelevant details, and the parameter explanations are separate, keeping the main description focused and scannable.

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 a simple tool with two optional parameters and no nested objects, the description covers the core functionality adequately. It lists the key health issues detected and the return behavior, though it omits details about the output schema or any performance implications. Still, the context is sufficient for an agent to use the tool correctly.

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

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

The schema provides only parameter names, types, and defaults, so the description adds essential meaning by explaining each threshold: 'CPU %% above which a running container is flagged' and 'memory %% of its limit above which a container is flagged.' This clarifies units and context beyond the bare schema, but lacks examples or edge-case handling 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 that the tool scans all containers and reports only those needing attention, listing specific conditions (OOM kills, restart loops, unhealthy health checks, crashes, high resource usage). It also mentions a clean-bill-of-health return, making the purpose unambiguous. The phrase 'instead of checking containers one by one' differentiates it from manual inspection.

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

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

The description provides a clear usage hint: 'use this instead of checking containers one by one,' which tells the agent when to choose this tool over manual per-container checks. However, it does not explicitly reference specific sibling tools or enumerate scenarios where other tools might be preferred, so some context is implicit 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?

No annotations are provided, so the description carries full responsibility for disclosing behavioral traits. It only mentions a dependency on the trivy CLI and does not state whether the operation is read-only, modifies state, or has side effects. 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 concise and well-structured. It leads with the primary action, then provides use cases, a conditional usage note, and a prerequisite, all in three sentences with no wasteful 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?

The description covers the tool's purpose, usage scenarios, and prerequisites. Since an output schema exists, it appropriately omits return-value details. It could mention that the tool may pull the image or run a network operation, but for a simple SBOM generator the provided context is sufficient.

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

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

Schema coverage is 0%, but the description compensates well by providing concrete examples for 'image' ('nginx:latest' or 'my-app:v1') and enumerating allowed values for 'format' ('cyclonedx' (default) or 'spdx-json'). This gives agents enough context to fill in both parameters correctly.

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

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

The description clearly states the main action ('Generates a Software Bill of Materials (SBOM) for a Docker image using Trivy') and the specific resource. It does not explicitly name an alternative sibling tool, so it falls short of a 5, but the purpose is unmistakable.

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 concrete use cases ('supply-chain compliance, license audits') and a condition for when to use the SBOM ('tracking exposure when a new CVE is disclosed (search the SBOM instead of re-scanning)'). It also states a prerequisite ('Requires the trivy CLI installed and on PATH'). However, it does not explicitly contrast with sibling tools like scan_image.

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 assumes the behavioral disclosure burden. It appropriately discloses the external hadolint CLI requirement and implies a non-mutating check by using the verb 'lints'. It does not explicitly state that the Dockerfile is not modified, but the wording makes the read-only style behavior reasonably clear.

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 yet informative, starting with the core action, then issue examples, sibling distinction, prerequisite, and parameter details. Each sentence adds value, and the example rule list is illustrative rather than filler.

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

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

For a single-parameter, read-only lint tool, the description covers purpose, scope, alternative tooling, installation requirement, and path conventions. Since an output schema exists, the description does not need to explain return structure, and 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?

The sole parameter, dockerfile_path, receives detailed treatment: it must be a full path to an existing Dockerfile, and both Windows-style and Git Bash-style paths are explicitly supported. Since the schema description coverage is 0%, this parameter information is essential and fully supplied by the description.

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

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

The description opens with a specific verb and resource: 'Lints a Dockerfile with Hadolint' and elaborates on best-practice issue types. It explicitly names the sibling scan_dockerfile and marks the distinction, so an agent can tell this tool apart without inspecting other definitions.

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?

It provides clear context for when to prefer this tool over scan_dockerfile by stating that scan_dockerfile focuses on security misconfigurations rather than style/best-practice rules. It also documents the hadolint CLI prerequisite. It does not offer explicit when-not-to-use conditions for other siblings, but the guidance is sufficient.

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, so the description carries the burden. It implies a read-only listing operation but does not explicitly state whether it has side effects, requires permissions, or how it handles errors.

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

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

The description is a single concise sentence with no filler or 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 zero-parameter list operation, the description is sufficient to understand the basic invocation. However, it does not describe the return structure or potential limitations, relying on the separately noted 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 tool has zero parameters and the schema description coverage is 100%, so there are no parameter semantics missing.

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 and result: 'Returns all containers with their status.' The tool name aligns with the purpose, though it could add detail about the scope of 'all containers'.

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 sibling tools like list_volumes or list_images. The description does not mention use cases, prerequisites, or conditions for selection.

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

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

With no annotations provided, the description carries the burden of transparency. The word 'lists' clearly indicates a read-only operation without side effects. However, it does not explicitly state that it makes no changes or require no special permissions. For a listing operation, this level of transparency is adequate, but a more explicit note would warrant a 5.

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, consisting of two short sentences. It provides necessary information without any redundancy, fluff, or extraneous details. The structure is straightforward and easy to parse.

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

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

The description covers the essential context: what it lists, the inclusion of untagged/intermediate images, and the output fields (short ID, tags, size). While it does not mention sorting, filtering, or output format beyond these fields, these are not critical for a simple listing tool. The description is complete enough for an agent to use the tool correctly.

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

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

The tool has zero parameters, so there is no parameter semantics to explain. The description avoids any irrelevant parameter details. According to the rubric, a baseline of 4 is appropriate when no parameters exist.

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: 'Lists all local Docker images, including untagged/intermediate ones.' The verb 'lists' is specific, and the resource is precisely identified as 'local Docker images.' It also distinguishes itself from sibling image-related tools by including untagged/intermediate images and specifying output details.

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 viewing images but does not explicitly state when to use this tool versus alternatives like pull_image, delete_image, or scan_image. There is no explicit guidance on conditions or scenarios where listing is preferred, so the 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?

As a listing operation, it implies read-only behavior with no side effects. However, the description does not explicitly state that it does not modify any resources or mention any permissions or rate limits. The lack of annotations places the full burden on the description, which is mostly adequate.

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

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

The description is a single, clear sentence with no superfluous words. It directly conveys the tool's purpose and output content.

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 listing tool, the description is complete. It states what is listed (all Docker networks) and what information is provided (driver and scope). No additional context is necessary for an agent to invoke it 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 tool has no parameters, so the empty input schema fully covers all possible inputs. The description does not need to elaborate on parameter details because there are none.

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 specifies the action ('Lists') and the resource ('all Docker networks') along with the relevant attributes ('driver and scope'). This distinguishes it from sibling tools like 'create_network' or 'list_containers'.

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

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

The description does not explicitly mention when to use this tool versus alternatives. While the purpose is obvious, it lacks direct guidance such as 'Use this to view network details, not to create or modify them.'

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It states the operation is a list, which strongly implies a read-only action without side effects. However, it does not explicitly say 'does not modify state' or mention any permission requirements. The lack of explicit disclosure is acceptable given the simplicity, but not exemplary.

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 conveys the essential information without unnecessary words. It is directly to the point and efficiently communicates the tool's 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?

Given the simplicity of the tool (no parameters, no output schema, no annotations), the description is fully complete. It tells the user exactly what the tool does and the scope of results. No additional context is needed for effective use.

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

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

The tool has no parameters, and the schema coverage is 100% (vacuously). Since there are no parameters to describe, the baseline score of 3 applies. The description adds no parameter-specific information because none exist.

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 (lists), the resource (compose projects), and the scope (including stopped ones). This removes ambiguity about whether running or stopped projects are included. It is a precise, unambiguous statement of 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 does not explicitly mention when to use this tool versus alternatives such as list_containers or list_networks. However, the tool name and description make its specific purpose clear; it is the only tool that lists compose projects. There is no direct guidance, but the context is sufficient for basic use.

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

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

The description indicates a read-only listing operation but does not explicitly confirm the absence of side effects or provide details about output format (e.g., JSON array). It does not mention any sorting, filtering, or pagination 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, focused sentence that conveys the essential function without redundancy. It is appropriately concise.

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

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

For a simple list operation, the description gives sufficient context, including the resource and the returned fields. However, it does not specify the return format or any potential error conditions, which could be useful for an agent.

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

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

There are no parameters, so the description's lack of parameter-specific details is fully appropriate. The empty input schema is trivially covered.

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 (Lists), the resource (Docker volumes), and the output details (driver and mountpoint). It distinguishes itself from sibling tools like create_volume and remove_volume by focusing solely on listing.

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

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

The description does not explicitly state when to use this tool instead of alternatives. It implies usage for inspecting volumes, but lacks explicit guidance about when not to use it, such as when needing to create or remove volumes.

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 transparency burden. It clearly discloses authrequirements and the non-credential-accepting behavior, and notes failure with missing alpine variants. It does not explicitly mention that pulling stores the image locally, but the primary side effect is implied well enough.

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 and every sentence adds value—no filler, repetition, or irrelevant detail. The structure flows naturally from action to prerequisites to parameter usage.

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

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

The tool is simple, and the description covers the essential context: what it does, when authentication is needed, how tags work, and the optional platform parameter. Since an output schema exists, omitting return-value details is acceptable.

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

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

Schema coverage is 0%, but the description thoroughly explains all three parameters: image (including embedded tag behavior), tag (default and retry guidance), and platform (optional architecture forcing). It adds substantial meaning beyond the bare schema.

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

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

The description clearly states the action ('Pulls a Docker image from a registry') and explicitly distinguishes it from running containers ('without running it'). It is immediately distinguishable from sibling tools like build_image, push_image, and run_container.

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 concrete usage guidance: it explains the need for prior docker login when auth is required, states that credentials are not accepted, and gives detailed tag-handling advice including when to use a different tag and when to retry with 'latest'.

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

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

The description discloses that the tool tags a local image and pushes it, and that it requires prior docker login. It does not mention potential side effects such as overwriting an existing remote tag or modifying the local image tag list, nor does it describe failure modes. Since there are no annotations, the description carries the burden but only partially covers behavior.

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

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

The description is concise and well-structured. The first sentence states the purpose, the second provides a prerequisite and a constraint, and the argument list gives examples in a clear bullet-like format. No extraneous information is included.

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

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

For a straightforward push operation, the description covers the essential preconditions and parameters. It does not explain the output or return value, but an output schema is present, so that information is available elsewhere. It also does not address edge cases like tag overwriting, but these are arguably beyond the scope for a basic tool description.

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 are clearly explained in the description text with examples: local_image is the current machine's image, repository is the full destination name, and image_tag is the tag to push. Although the schema itself lacks descriptions (coverage 0%), the description provides full semantic coverage, so the added meaning is high.

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: it tags a local Docker image with a registry repository name and pushes it. It also provides concrete examples (Docker Hub, AWS ECR) that situate it within the container management context. While it does not explicitly name a sibling tool, the action (push) is distinct from pull, build, and list operations, 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 description mentions a prerequisite (docker login) and explicitly states that credentials are not accepted, but it does not provide guidance on when to choose this tool over alternatives (e.g., when to use push_image versus pull_image or build_image). It lacks a 'use this when...' or 'use that instead when...' recommendation.

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. It explicitly discloses permanent removal, data deletion, and the preview/confirm two-step behavior. It also notes that user agreement is required before confirming. This is highly transparent 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 is well-organized with a clear opening statement, behavior explanation, and structured Args section. It is not overly verbose, though the Args section partially duplicates the schema; the added explanations justify the length. All sentences carry meaningful information.

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

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

Given the destructive nature, the description covers the core action, the confirm mechanism, and both parameters. It doesn't mention error cases or return details, but the output schema presumably handles returns. Minor gaps like failure states or idempotency are not critical for a tool with clear confirm semantics.

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

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

Schema coverage is 0%, but the description's Args section fully explains both parameters: project_name as the unique stack identifier and confirm as a boolean that must be True to perform removal, defaulting to False. This adds essential meaning beyond the schema's type-only definitions.

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

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

The description clearly states it 'Stops and permanently removes a compose stack: containers, networks, and volumes (data is deleted).' It specifies the verb, resource, and scope, and distinguishes from siblings like stop_stack (which stops but doesn't remove) and delete_container (which removes a single container). The permanent removal and data deletion are explicit.

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

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

The description explains the critical two-step usage: the first call (confirm=False) only previews, and confirm=True is required for actual removal after user agreement. This is a clear usage guideline. However, it does not explicitly contrast with alternatives such as stop_stack or delete_container, so the when-to-use vs alternatives 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?

The description warns that data is permanently lost, making the destructive nature explicit. It also explains the two-step confirmation behavior, which is a significant side-effect control. Since no annotations are provided, the description carries the full burden of transparency, and it does so effectively.

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 bit verbose but each sentence adds necessary warnings or behavioral details. The structure clearly separates the action, the preview behavior, and the parameter explanations. It is well-organized, though the confirm behavior is slightly repeated in the Args section.

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

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

The description covers the core behavior, the preview mode, the failure condition, and the permanent data loss. It also explains the confirm flag clearly. Given the output schema is present, the description does not need to detail return values. It is sufficiently complete for an agent to use the tool correctly.

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

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

The description explains volume_name as the name of the volume to delete, and confirm as a boolean that must be True to perform the deletion, with a default of False. This fully covers both parameters despite the schema having no descriptions. The semantics are clear and actionable.

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: 'Deletes a Docker volume by name.' It also specifies the resource and distinguishes it from related operations like removing stacks or containers. The verb 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 explicitly explains the confirm flag behavior, noting that the first call only previews and that confirm=True is required to actually delete. It also states a key failure condition: the volume must not be in use by a container. This gives clear guidance on how to invoke the tool safely.

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 revealing side effects. It mentions running a container locally but does not disclose that it creates a new container, maps ports, pulls images if missing, or whether the container runs detached. The default alpine tag behavior is mentioned, but other significant side effects are omitted.

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 relatively concise and structured with an 'Args:' section and clear parameter lines. However, it contains a typo ('usel' instead of 'use') and a slightly run-on sentence, which slightly detracts from clarity.

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

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

Given that the tool has four required parameters and an output schema exists, the description adequately covers all necessary inputs and the overall purpose. It does not explain the return value, but that is expected to be covered by the output schema, so the description is complete enough for an agent to 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 schema provides no descriptions, but the description explains all four parameters (image, container_name, container_port, host_port) with concrete examples and the image default behavior. This fully compensates for the 0% schema description coverage.

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

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

The description clearly states the tool 'Runs a Docker container locally for testing', providing a specific verb and resource. It is distinct from sibling tools like container_start (which starts an existing container) but does not explicitly name alternatives.

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

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

The description gives examples for each argument and explains the default alpine tag behavior, but it does not explicitly state when to prefer this tool over sibling tools like container_start or deploy_stack. The intended use case is implied but not explicitly contrasted with alternatives.

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

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

The description implies read-only scanning behavior and indicates it produces findings ('Flags things like...'), but it does not specify the output format, return value, error behavior, or whether it modifies anything. With no annotations, this transparency is only partial.

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

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

The description is efficiently structured with a clear opening statement, a useful list of example checks, a prerequisite, and parameter details. It is slightly longer than strictly necessary but all content contributes to understanding, and the structure is logical.

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

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

The description covers the tool's purpose, prerequisites, and parameters adequately. However, it lacks information about the output format or exit/error behavior, which is important for a scanning tool. It also does not mention if severity values are validated or constrained, leaving some operational gaps.

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

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

The description explains both parameters in detail beyond the bare schema: dockerfile_path is described with path format examples (Windows and Git Bash), and severity is described as comma-separated with a default value. This fully covers the schema's 0% description coverage.

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

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

The description clearly states the primary function: 'Scans a Dockerfile for security misconfigurations using Trivy's config scanner.' It also adds differentiating context with 'BEFORE the image is even built' and lists specific findings, distinguishing it from sibling tools like scan_image.

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?

It gives practical usage guidance by noting the prerequisite (trivy CLI on PATH) and the timing ('BEFORE the image is even built'). However, it does not explicitly contrast with alternatives like lint_dockerfile or audit_dockerfile, so the when-to-use is somewhat implicit 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?

The description discloses that Trivy must be installed and that the first scan downloads the vulnerability database, which is a side effect. However, it does not state whether the scan is read-only, whether images may be pulled, what output format is returned, or how failures are reported. With no annotations, the description carries full responsibility for behavioral transparency.

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

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

The description is well-organized with a short introductory paragraph, a note about defaults, and an Args list. It is slightly redundant because the default severity is mentioned both in prose and in the Args section, but the text remains efficient and readable.

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

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

The description covers prerequisites, side effects, and parameter semantics, which is helpful. However, it does not describe the expected return value or output schema, and it lacks guidance on when to use this tool versus related scanning tools. For a moderately simple tool this is acceptable but not fully complete.

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

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

Both parameters are clearly explained in the description despite the schema having no descriptions. The image parameter includes examples, and severity explains the comma-separated format and default value, fully compensating for the missing schema descriptions.

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

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

The description clearly states that the tool scans a Docker image for known vulnerabilities using Trivy. It identifies the specific resource (Docker image) and action (scan), making the tool's 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 description provides prerequisites and notes the first-run database download, but it does not mention when to prefer this tool over sibling tools such as scan_dockerfile or generate_sbom. No explicit alternative guidance or 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?

No annotations are provided, so the description carries the full burden. It only says 'Collects logs' without disclosing side effects, permissions, or whether it is read-only. There is no mention of potential large output or formatting details.

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

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

The description is brief and to the point, with a clear one-line summary followed by a compact Args list. No redundant language 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?

The presence of an output schema covers the return structure, and the description provides enough to understand the tool's purpose for a simple log retrieval. It does not mention output formatting or combined log order, but this is not critical for a logs tool and sibling tools likely follow similar patterns.

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

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

Despite 0% schema coverage, the description explicitly explains both parameters (project_name and tail) and notes the default for tail. This fully compensates for the missing schema descriptions.

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

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

The description clearly states the action ('Collects logs') and the target ('all containers in a compose stack'), which distinguishes it from container_logs (likely single-container). The verb and resource are specific and unambiguous.

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

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

The description implies usage when logs are needed from an entire stack, but it does not explicitly state when to use this tool over alternatives like container_logs, nor does it provide any contextual prerequisites or exceptions.

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 of disclosing side effects. It states the action (shows status) which implies a read-only operation, but it does not explicitly confirm that no modifications occur, nor does it mention any permissions or side effects.

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

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

The description is brief and to the point, with the primary action stated first. The parameter explanation is concise and directly relevant, with no superfluous information.

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

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

For a simple read-only status tool with a single parameter, the description provides sufficient context to call it correctly. It does not detail the return format, but the presence of an output schema likely covers that, and the tool's purpose is clear.

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 no description for the parameter, but the tool description adds a meaningful explanation: 'unique name for this stack, used to group/manage its containers'. This clarifies the parameter's role and compensates for the schema's lack of description.

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

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

The description clearly states the tool's function: showing the status of all containers in a compose stack. The analogy to 'docker compose ps' is immediately recognizable and distinguishes it from sibling tools like stack_logs or list_stacks.

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 via the 'docker compose ps' analogy, but it does not explicitly state when to use this tool over alternatives. No direct comparison to sibling tools is provided, leaving the agent to infer the appropriate context from the action alone.

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

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

With no annotations, the description carries the full burden. It only states 'stop' without disclosing side effects, whether the container is removed or merely halted, failure conditions, or whether the operation blocks until stopped.

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 brief and to the point, with no redundant wording. It is slightly awkward with 'User will pass' but still structurally efficient.

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

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

For a simple tool this is very sparse. It does not mention expected output, error behavior, whether the container must already exist, or whether it can be restarted later. Even with a simple operation, an agent needs more context to use it reliably.

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 parameter schema is minimal and the description adds little beyond repeating that it is a container name. No format, validation, examples, or constraints are provided, so the description does not meaningfully enrich 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 identifies the action as stopping a Docker container by name, and the tool name reinforces this. It is unambiguous and distinct from sibling actions like starting, restarting, or deleting containers.

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 the many sibling tools. It does not explain scenarios where stopping is appropriate, nor does it contrast with start, restart, or delete.

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 explicitly states the non-destructive nature ('without removing them') and the resumability, which are key behavioral traits. It omits edge cases like handling non-existent stacks, but core behavior is transparent.

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

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

The description is concise and well-structured, with the purpose stated in the first sentence and parameter documentation in a clean list. No redundant or extraneous information is present.

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

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

For a simple one-parameter operation, the description provides sufficient context: what it does, what it preserves, and the parameter's meaning. It does not mention return values or error behavior, but given the tool's simplicity and the absence of an output schema in the example, this is 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?

The description includes an Args section defining project_name as 'unique name for this stack, used to group/manage its containers,' which adds meaningful context beyond the schema's minimal type/title. This adequately explains the parameter's role, though it could mention how to discover 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 tool stops all containers in a compose stack without removing them, and explicitly notes it can be started again later. This distinguishes it from stop_container and remove_stack, providing a precise 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 phrase 'without removing them, so it can be started again later' implicitly guides when to use this tool versus a removal tool. However, it does not explicitly compare to sibling tools like stop_container or remove_stack, leaving some inference to the agent.

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