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

No annotations provided, so description fully handles transparency. Clearly states it's a read operation, describes return envelope with truncated flag, and explains behavior when history is incomplete.

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

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

Two well-structured paragraphs: first describes action and parameters, second describes return format. Front-loaded with summary, no redundant information.

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

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

Complete for a 3-parameter read-only tool. No output schema, but description explicitly documents return envelope and truncated behavior. No gaps.

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

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

Schema coverage is 0%, but description explains all three parameters: container_id (id or name), tail (range 1..2000, default 100), target (from config, omit for default). Adds value beyond 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?

Clear specific verb 'Tail' and resource 'log lines of a container' with explicit mention of stdout/stderr. Distinguished from siblings like container_top (processes) and container_stats (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?

Provides explicit instruction on interpreting truncated result and re-running with higher tail. Lacks explicit when-not or naming of alternatives, but the context is clear for a read-only log retrieval tool.

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

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

With no annotations, the description carries full disclosure burden. It correctly declares the operation as read-only via '[READ]' and describes the sorting behavior. However, it does not specify the scope (e.g., all containers in the Docker host or a specific project) or any potential side effects, though read operations are unlikely to have any.

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

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

The description is extremely concise, with no extraneous words. It uses a single-line summary and bullet-like parameter explanations. All content is relevant and front-loaded.

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

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

Given the tool's simplicity (2 optional parameters, no output schema), the description covers the core functionality and parameters. However, it lacks any mention of the output format (e.g., list of containers with counts), which would be helpful for an agent to understand the return structure.

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 compensates well. It explains both parameters: 'all_states' determines whether to inspect all containers or only running ones, and 'target' selects a config context. This adds meaning beyond the schema's type and defaults.

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

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

The description clearly states it provides a 'restart-count + exit-code summary across containers, worst-first.' The '[READ]' prefix and sibling tool names like 'restart_container' and 'inspect_container' help distinguish it as a read-only aggregation tool.

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 troubleshooting by noting 'worst-first' sorting, but it does not explicitly state when to use this tool over siblings like 'inspect_container' or 'container_stats'. No exclusions or alternatives are mentioned.

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

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

No annotations provided, but the description includes '[READ]' indicating a read-only operation and 'one-shot' indicating non-streaming. However, it does not disclose potential side effects, authentication needs, or rate limits.

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 front-loaded with the purpose. Every sentence adds value ('[READ] One-shot...', then clear Args). No redundancy or 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?

For a simple read tool with two parameters and no output schema, the description adequately covers purpose and parameters. It does not explain return format or error behavior, but these are not critical given the simplicity.

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

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

The description adds meaning to both parameters: container_id can be 'id or name', and target is 'from config' with a note to omit for default. Schema had 0% description coverage, so this compensates well.

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's a '[READ]' operation for a 'One-shot CPU%/memory% snapshot', specifying the resource (container stats) and distinguishing it from sibling tools like container_top (process listing) or inspect_container (detailed info).

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 provide guidance on when to use this tool versus alternatives. It mentions 'one-shot' and 'stream=false', but there is no explicit comparison or recommendation for selecting this over sibling tools.

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

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

With no annotations provided, the description must fully disclose behavior. It labels the tool as [READ] indicating non-destructive operation, but does not detail any side effects, permissions needed, or output format. Minimal transparency beyond the core function.

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

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

The description is extremely concise: a one-line summary followed by a bulleted args list. Every sentence adds value, no redundancy. Front-loads the key information.

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

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

Given the tool's simplicity (list processes, 2 params, no output schema), the description covers the essentials. It could mention limitations like only current snapshot, but for a basic read tool, 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?

The schema has 0% description coverage, so the description's 'Args' section adds critical meaning: it explains container_id as 'Container id or name' and target as 'Target name from config; omit for the default.' This 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 tool reads processes inside a container, using the familiar 'docker top' analogy, which immediately conveys its purpose. It distinguishes from siblings like container_logs or container_stats by specifying the exact function.

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

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

The description implies usage when you need to see running processes inside a container, but does not explicitly state when to use this tool versus alternatives (e.g., container_stats for resource usage, container_logs for logs). No exclusions or alternatives 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?

The description marks the tool as [READ], indicating no modifications. It also mentions 'reclaimable bytes' and 'prune candidates', which clarifies the read-only, advisory nature. With no annotations, this provides adequate 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, with a clear title and an Args section. No unnecessary words. Could be slightly more structured but 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?

Given the simple tool (one parameter, no output schema), the description covers purpose, parameter usage, and behavioral nature. It does not reference sibling tools, but for a straightforward listing command, completeness 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?

The schema has 0% parameter description coverage, but the description explicitly explains the 'target' parameter as a name from config with a default when omitted, adding necessary meaning beyond the schema.

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

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

The description clearly states it lists untagged (dangling) images and reclaimable bytes, with a specific verb/resource. It distinguishes from sibling tools like list_images (all images) and prune_images (removal).

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 pruning candidates but does not explicitly state when to use this tool versus alternatives like list_images or image_disk_usage. No direct exclusions or alternative references.

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 bears full burden. It explicitly marks the operation as READ (non-destructive) and describes the output as dangling volumes and reclaimable bytes. This adequately discloses behavioral traits for a read operation.

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

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

The description is concise, with a header line stating the purpose and an Args section for the parameter. It is front-loaded with key information and avoids unnecessary details, though it could be slightly more structured.

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

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

Given the tool's simplicity (one optional parameter, read-only operation), the description covers the essential aspects: what it lists and the parameter usage. No output schema exists, but the return values (dangling volumes and bytes) are implied.

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 information for the single parameter 'target'. The description adds meaningful context: 'Target name from config; omit for the default.' This explains the parameter's purpose and default behavior, significantly enhancing semantic understanding beyond the schema.

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

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

The description clearly states it lists dangling volumes and their reclaimable bytes, and identifies them as prune candidates. It uses a specific verb ('list') and resource ('dangling volumes'), and the context of 'prune candidates' distinguishes it from sibling tools like 'list_volumes' and 'prune_volumes'.

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

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

The description implies the tool is for finding candidate volumes to prune, but it does not explicitly state when to use it versus alternatives like 'prune_volumes' or 'list_volumes'. No exclusion criteria or when-not-to-use guidance is provided.

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

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

No annotations provided, so description carries full burden. It discloses the read-only nature, aggregation into prune candidates sorted largest first, and the skip-live behavior when payloads are passed. Missing details on output format but otherwise 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: a clear first line with [READ] and summary, followed by explanation and a bulleted args list. Every sentence adds value with no 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?

Given 4 optional parameters and no output schema or annotations, the description covers usage, parameter semantics, and output behavior adequately. It provides enough context for a read-only aggregation tool.

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

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

Schema coverage is 0%, but description details all 4 parameters: dangling_images, dangling_volumes, df, and target. It explains their structure and usage, adding significant value beyond the schema.

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

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

The description clearly states it sums dangling images, volumes, and build cache into reclaimable-byte prune candidates, with a [READ] tag indicating read-only. This distinguishes it from sibling tools like dangling_images and dangling_volumes.

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 two usage modes: pass pre-injected payloads for pure analysis or target for live data. It implicitly suggests when to use this aggregation tool vs siblings, but does not explicitly exclude scenarios.

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

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

With no annotations, the description must disclose behavior. It declares the operation as read-only via '[READ]' tag and specifies the data source and output fields (total, shared, reclaimable). It does not detail potential errors, permissions, or side effects, but for a simple read operation this is 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 extremely concise, using two short sentences. It front-loads the read indicator and immediately states the purpose. No unnecessary words or redundancy; every phrase adds value.

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

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

Given the tool's simplicity (one optional param, no output schema), the description covers the essential aspects: source, data fields, and parameter usage. It does not specify the return format (e.g., numbers, object), but for a straightforward read 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 schema has 0% description coverage, so the description must compensate. It explains the 'target' parameter as 'Target name from config; omit for the default.', adding meaningful context beyond the schema's type and default. This is sufficient for a single optional parameter.

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

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

The description clearly states the verb 'READ' and the resource 'image disk usage', specifying it comes from system/df and returns total, shared, reclaimable. This distinguishes it from sibling tools like system_df (system-wide) and list_images (listing), 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 implies usage for querying image disk usage but provides no explicit guidance on when to use this tool versus alternatives like system_df or inspect_image. No exclusion criteria or alternatives are mentioned, though the context of siblings helps infer its niche.

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?

Only indicates it is a read operation via '[READ]', but no annotations are provided to confirm. No details on error behavior, permissions, or side effects. Minimal disclosure beyond the operation type.

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?

Very concise: two short paragraphs, front-loaded with the core purpose. Every sentence adds value with no 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?

Given only 2 parameters, no output schema, and no nested objects, the description covers the essential aspects: operation type, scope, and parameter meanings. Could mention return format (e.g., JSON) but still sufficient for basic 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?

With 0% schema description coverage, the description compensates by explaining both parameters: 'container_id' as 'Container id or name.' and 'target' as 'Target name from config; omit for the default.', adding meaning beyond the bare type 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 a read operation ('[READ]') and specifies what is inspected ('config, state, mounts, network'), distinguishing it from sibling tools like 'list_containers' (list vs inspect) and 'inspect_network'.

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

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

No explicit guidance on when to use this tool versus alternatives, such as when to use 'inspect_container' over 'container_top' or 'inspect_network'. No conditions 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?

The description includes '[READ]' indicating read-only operation, which is helpful. However, no annotations are present, and the description does not explicitly confirm idempotency, safety, or potential performance implications. It lacks detail beyond the verb tag.

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, with a clear purpose line followed by an Args section. It is front-loaded with '[READ]'. However, the Args section could be more structured, and the overall length is appropriate for the tool's simplicity.

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

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

The description covers the purpose and explains both parameters. However, it does not describe the output or return values, which is notable since no output schema is provided. Given the tool's simplicity, it is mostly complete but lacks return format details.

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

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

The description adds meaning to both parameters beyond the schema: image_id is 'Image id or name:tag', and target is 'Target name from config; omit for the default.' With 0% schema description coverage, this provides essential clarity.

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 inspects an image and its build history, including layers, sizes, and commands. This differentiates it from sibling tools like list_images which only lists images, and inspect_container which inspects containers. However, it could be more explicit about what 'build history' encompasses.

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

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

No guidance is provided on when to use this tool versus alternatives like inspect_container or list_images. The description does not specify prerequisites, typical use cases, or when to avoid using 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?

The description begins with [READ] indicating a read-only operation and lists the information it retrieves. As no annotations are provided, this adequately communicates the behavioral trait of being non-destructive, though additional context (e.g., authentication) is not included.

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 [READ] prefix, a one-line purpose, and a bulleted argument list. Every part is informative and earns its place.

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

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

The tool is simple with one required parameter, and the description covers its purpose and arguments. However, with no output schema, describing the return format (e.g., a JSON object) would increase completeness. Nonetheless, it is adequate for its context.

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

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

Schema description coverage is 0%, but the description adds essential semantics: network_id accepts id or name, target is optional with a clear default behavior. This goes 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 inspects a single network, detailing specific attributes (driver, IPAM subnet/gateway, attached containers). This distinguishes it from list_networks, which lists all networks, and other inspect tools.

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

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

The description implies usage for detailed inspection of a specific network but does not explicitly state when to use this tool versus alternatives like list_networks for overview or other inspect tools for different resources.

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?

Prefix [READ] indicates read-only. Lists returned fields (driver, mountpoint, options, usage). No annotations provided, but description adequately covers behavior for a simple inspection 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?

Very concise: one-line purpose, then Args section. No wasted words. Front-loaded with key 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?

Covers all needed context for a simple inspect tool: what it inspects, key output fields, and parameter explanations. No output schema, but description sufficiently describes returns.

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?

Adds context beyond schema: explains 'name' as volume name and 'target' as config target with default omission. Schema has 0% coverage, so description compensates well.

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 'Inspect one named volume' with specific details returned. Differentiates from sibling inspect tools by focusing on volumes.

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

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

No explicit guidance on when to use this tool over alternatives like list_volumes. The parameter descriptions are clear but do not address selection context.

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

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

The description includes a [READ] tag indicating it's read-only and explains the reconstruction from labels. Without annotations, it provides basic behavioral context but lacks details on potential performance implications or caching.

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 with a clear summary and structured Args section. The front-loaded sentence captures the essence, but could be slightly more direct.

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

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

Given the simple parameter and no output schema, the description is moderately complete. It explains the core functionality but omits details on how stacks relate to other concepts and the exact health rollup interpretation.

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%, and the description only gives a one-line explanation for the 'target' parameter ('Target name from config; omit for the default.'). No additional semantics like example values or constraints.

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 groups containers into Compose projects with a health rollup, and explains it works on both Docker and Podman. However, it doesn't fully distinguish from the sibling tool 'list_stacks', which could be similar.

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

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

No explicit guidance on when to use this tool versus alternatives. No when-not-to-use or context provided for choosing between list_compose_stacks and siblings like list_containers or list_pods.

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

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

With no annotations, the description must disclose behavioral traits. It mentions 'bucketed by state' and 'compact rows', and explains the all_states parameter (list all vs only running). However, it does not describe output format, pagination, error handling, or side effects, leaving gaps for a list 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 extremely concise: one line for purpose and two lines for parameters, with no redundancy. Every sentence adds value, and the arg list is well-structured. It avoids fluff and is easy to parse quickly.

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

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

Given the tool's simplicity (2 simple params, no nested objects) and lack of output schema, the description covers the essentials. However, it omits details about the return format or any side effects, which would help an agent fully understand the tool's behavior without additional context.

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

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

The input schema has 0% description coverage, so the description carries the full burden. It clearly explains both parameters: all_states (True lists all, False only running) and target (target name from config, omit for default). It adds meaning beyond the schema's property names and defaults.

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

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

The description clearly states the action: 'List containers, bucketed by state, with compact rows.' It specifies the resource (containers) and the mode (list), distinguishing it from sibling tools like inspect_container or list_pods. The '[READ]' prefix reinforces the read-only nature.

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 vs alternatives such as inspect_container or container_logs. No guidance on when not to use it or which tool to prefer for different needs is provided, leaving the agent to infer usage from the generic 'list' purpose.

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 disclosure. It explicitly marks the operation as '[READ]' and lists the fields returned, indicating no destructive side effects. It also notes the requirement of a Portainer target, implying authentication context.

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

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

The description is extremely concise: two sentences plus one Args line. It front-loads the key purpose and returns immediately, with no wasted words. Every sentence adds value.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description provides all necessary context: what it returns (fields), what it requires (target), and how to use the parameter. It is complete for an agent to invoke correctly.

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

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

The input schema has 0% description coverage for the 'target' parameter, but the description compensates fully by explaining: 'Target name from config; omit for the default.' This adds clear meaning beyond the schema's type 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 '[READ] Portainer endpoints (managed hosts)' and lists the specific fields returned (id, name, type, status, url). This distinguishes it from sibling tools like list_pods or list_containers, which target different resources.

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

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

The description specifies a prerequisite ('Requires a portainer target') and explains the target parameter, giving clear context for usage. However, it does not explicitly state when not to use this tool or mention alternatives, though none exist among siblings.

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

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

With no annotations, the description correctly indicates a READ operation ([READ]), explains the args, and mentions ordering. It does not disclose return format or potential size limits, but is otherwise 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, with a clear purpose line and bullet-like arg explanations. No unnecessary words.

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

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

For a simple list tool with two parameters and no output schema, the description covers the core purpose and args. It could mention return format or pagination, but overall it's complete enough.

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%, yet the description explains both parameters: 'all_images' includes intermediate layers vs top-level, and 'target' is for a config target. This adds significant meaning beyond the schema.

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

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

The description clearly states the tool lists images with attributes (tags, size, dangling) and sorts largest first. It distinguishes itself from siblings like 'dangling_images' and 'inspect_image' by offering a broad listing with sort.

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 on when to use this tool versus alternatives (e.g., 'dangling_images' for only dangling images, 'inspect_image' for details). The description does not mention exclusions or context.

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

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

With no annotations, the description clearly indicates a read operation via [READ] and explains the grouping behavior ('bucketed by driver'). This provides adequate transparency for a non-destructive 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 extremely concise, front-loaded with the [READ] tag, and presents the purpose and parameter in a clear, structured format with no unnecessary words.

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

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

For a simple list tool with one optional parameter and no output schema, the description covers the key aspects: what it does, grouping, and parameter meaning. The lack of output format is acceptable given the tool's simplicity.

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 no descriptions for the single parameter 'target'. The description adds meaning: 'Target name from config; omit for the default.' This clarifies the parameter's origin and default behavior, compensating for the 0% schema coverage.

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

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

The description clearly states 'List Docker networks, bucketed by driver.' This is a specific verb (list) and resource (Docker networks) with additional grouping detail that distinguishes it from other list tools like list_containers or list_volumes. The [READ] prefix further clarifies the action.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., inspect_network for details). The description does not mention prerequisites or when to avoid using 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 provided; description compensates by labeling as [READ] (non-destructive) and explaining error behavior for incorrect targets. Discloses key behavioral traits for a list 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?

Two concise paragraphs with front-loaded purpose. Every sentence adds value; no wasted words.

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

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

Covers purpose, usage guidelines, parameter, and error behavior adequately. Could optionally detail return format, but title already lists fields; overall sufficient for a simple list tool.

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

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

One optional parameter (target) with schema coverage 0%; description adds context that target comes from config and omitting uses the default, which is meaningful beyond the schema.

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

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

Clearly states the tool lists Podman pods and specifies the fields returned (id, name, status, member containers). Distinguishes from sibling tools like list_containers by emphasizing Podman-only.

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?

Explicitly states that it requires a podman target and will return a teaching error on docker/portainer targets, providing clear when-to-use and when-not-to-use guidance.

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

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

No annotations provided, so description carries full burden. Explicitly marks as [READ] (read-only), mentions requirement of a portainer target, but lacks details on authentication, rate limits, or potential 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?

Two sentences, front-loaded with purpose and output fields, then parameter guidance. No wasted words, efficiently structured.

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

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

Lists output fields, which is helpful given no output schema. However, lacks details on pagination, filtering, or sorting behavior that might be relevant for a list operation.

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

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

Schema description coverage is 0%, but description adds meaning for the only parameter 'target': explains it as 'Target name from config; omit for the default', effectively compensates for schema gaps.

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?

Clearly states verb 'list' and resource 'stacks', specifies returned fields (id, name, type, endpoint, status), and distinguishes from sibling 'stack_detail' and 'list_compose_stacks' by covering both Compose and Swarm.

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?

Describes the target parameter and default behavior, but does not explicitly guide when to use this tool over alternatives like list_compose_stacks or stack_detail, nor provides when-not-to-use conditions.

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?

Uses '[READ]' to indicate read-only operation, and lists output fields. With no annotations provided, the description adequately conveys behavioral traits, though it could mention prerequisites or side effects if any.

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?

Extremely concise: two sentences front-load the read status and purpose, then describe the parameter. No wasted words.

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

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

Given the simple input (one optional param) and no output schema, the description provides sufficient detail to understand purpose and return values. Could potentially mention if there is any filtering or pagination, but not essential.

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?

Explains the single parameter 'target' with its purpose ('Target name from config') and behavior when omitted ('use the default'). This adds significant value beyond the schema, which has 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?

Clearly specifies the verb 'List' and resource 'volumes', and details the fields returned (name, driver, mountpoint, scope). Distinguishes from sibling list tools by targeting volumes specifically.

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?

Describes what the tool does and mentions omitting target for default, but does not provide explicit when-to-use or when-not-to-use guidance relative to sibling tools like list_containers or list_networks.

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 marks the tool as [READ], indicating it is non-destructive. It describes the output content (version, container state rollup, disk) but does not elaborate on performance, data freshness, or any rate limits. Given no annotations, the transparency is good but not exhaustive.

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: a one-line summary with [READ] prefix, a usage sentence, and a parameter note. Every sentence serves a purpose, and the key information is front-loaded.

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

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

Given the tool has one optional parameter, no output schema, and no annotations, the description sufficiently covers purpose, usage context, and parameter semantics. It explains when to call and what to expect, making it complete for an overview tool.

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

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

For the single optional parameter 'target', the description explains it is a 'Target name from config' and to omit for the default. This adds contextual meaning beyond the schema's type and default, though 'config' could be clarified.

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 it provides a 'One-shot host overview: version + container state rollup + disk.' The [READ] prefix and triage guidance clearly distinguish it from sibling tools that focus on specific resources.

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

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

The description directly says 'Call this first to triage a container host before drilling into a specific container, image, or volume.' This gives explicit when-to-use advice and implies alternatives are the more specific tools.

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

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

Discloses high risk, no undo, and parameter effects (dangling_only, dry_run). Dry-run output is described. Lacks mention of auth requirements or error scenarios, but adequate given annotation absence.

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?

Structured with risk badge, short paragraph, and clear parameter list. Every sentence adds value; no waste.

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

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

Covers key aspects but does not specify output format or return values for non-dry-run mode, leaving ambiguity in the absence of an output schema.

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

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

With 0% schema description coverage, the description fully compensates by explaining each parameter's default and effect, including dry_run behavior and reclaimable bytes.

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 as a write operation for pruning images, specifies default behavior (dangling only), and contrasts with read-only siblings.

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

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

No explicit guidance on when to use this tool vs alternatives like 'dangling_images' or 'list_images'. Dry-run safety is mentioned but context for selection is absent.

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

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

With no annotations, the description carries full burden. It discloses high risk, no undo, and the dry_run preview behavior, which is good for a destructive tool, though it lacks details on permissions or error handling.

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

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

The description is very concise: a headline with key warnings and a short Args section. Every sentence is valuable, front-loading the most critical information (write, risk, no undo).

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 main usage and dry_run behavior, and with only two optional parameters, it is largely complete. However, it omits return format for the non-dry-run case and potential side effects.

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 compensates by explaining dry_run lists what would be removed and reclaimable bytes, and target is a config name. This adds meaningful context beyond the schema's type/default 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 it prunes unreferenced (dangling) volumes, with a [WRITE][risk=high] tag and 'No undo.' This specific verb-resource combo distinguishes it from sibling tools like list_volumes or dangling_volumes.

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 removing dangling volumes and mentions dry_run for preview, but does not explicitly state when to use this tool versus alternatives like list_volumes or dangling_volumes, nor does it provide when-not to use guidance.

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

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

No annotations are provided, so the description bears full responsibility. It explicitly states the tool is a write operation with high risk, has no undo, captures the stack definition for audit, and requires a target. This is comprehensive behavioral disclosure.

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

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

The description is well-structured with a bold first line summarizing risk, followed by a brief explanation, and a clear Args list. 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?

Given the complexity of a high-risk mutation tool and no output schema, the description explains the process (audit capture, no undo) but does not describe the return value or what happens on success/failure. It is mostly complete but missing output details.

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

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

With 0% schema description coverage, the description compensates fully by explaining each parameter in the Args section: stack_id (Portainer stack id), endpoint_id (omit to use own), dry_run (preview), and target (from config or default).

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 redeploys (recreates) a Portainer stack with the verb 'Redeploy' and resource 'Portainer stack'. It distinguishes from sibling stack tools (list_stacks, stack_detail) by focusing on the recreation action, and adds specificity with 'No undo' and audit capture.

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?

Provides clear context: it's a high-risk write operation with no undo, requires a portainer target, and offers a dry-run preview. It doesn't explicitly list when not to use or compare with alternatives, but the action is unique among siblings, so it's implicit.

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

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

With no annotations, the description fully discloses behavioral traits: captures inspect before deletion, no undo, high risk, and parameter effects (force, remove_volumes). This exceeds the minimum needed for safe invocation.

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 with a clear header, risk notice, explanation of behavior, and a structured Args list. 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?

Given the 5 parameters, no output schema, and no annotations, the description covers all necessary aspects: what the tool does, its irreversible nature, audit trail, and parameter roles. It is complete for an agent to use 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%, but the description provides a clear Args block explaining each parameter (container_id, force, remove_volumes, dry_run, target). This adds essential meaning beyond the schema's field names and defaults.

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

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

The description clearly states 'Remove a container' and distinguishes this destructive action from sibling tools like start, stop, restart. The verb 'remove' and resource 'container' are explicit, and the context signals list many container-related siblings, making the purpose distinct.

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 'No undo' and 'Pass dry_run=True to preview', guiding safe usage. However, it does not explicitly state when to use this tool versus alternatives (e.g., stop_container for graceful shutdown). Still, the context implies this is for permanent removal.

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 the read-only nature with '[READ]' and details the process: one-shot sample, flagging thresholds, and attaching recommendations. With no annotations provided, the description carries full burden and meets it well, though it could mention whether it modifies state (it doesn't).

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

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

The description is well-structured with a summary line, a detailed behavior paragraph, and a clear Args list. It is concise but not overly terse, though the second paragraph could be slightly tighter.

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

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

Given no output schema, the description only vaguely mentions 'Every row carries its numbers' and recommendations. It lacks explicit output fields or format, which is a gap for a tool that produces ranked, structured results.

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

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

Schema description coverage is 0%, but the description's Args section explains all four parameters (cpu_threshold, mem_threshold, samples, target) with defaults and usage, adding significant meaning beyond the raw 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 ranks containers by CPU and memory pressure against thresholds and provides recommendations. It specifies the verb (rank, recommend) and resource (containers), and distinguishes itself from sibling tools like container_stats by focusing on pressure analysis with recommendations.

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 one-shot pressure analysis but does not explicitly contrast with alternatives (e.g., container_stats for live stats, container_logs for history). It provides no when-not-to-use guidance, so the agent must infer usage context.

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

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

No annotations provided, so description carries full burden. It discloses that the tool is a write operation with medium risk, captures prior state, has no meaningful inverse, and supports dry_run. This is transparent about the mutating nature and safety, though it could mention permissions or failure modes.

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 with a risk tag, summary, behavioral note, and structured Args block. No extraneous content, but the informal '[WRITE][risk=medium]' could be cleaner. Overall efficient and well-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?

Despite no annotations or output schema, the description covers the tool's action, risk profile, parameters, and dry_run feature. It lacks return value details and error handling, but for a simple restart operation, it provides sufficient context for an agent to use 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 coverage is 0%, but the description provides detailed parameter documentation: container_id, timeout (with default and unit), dry_run (with effect), and target (with usage context). This adds essential meaning beyond the schema's raw type 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 that the tool restarts a container and captures prior state for audit. It uses specific verbs and resources ('Restart a container') and distinguishes from siblings like start/stop by highlighting audit logging. The no-undo behavior is explicitly stated.

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 implicitly indicates usage for restarting containers with audit needs, and mentions dry_run for preview. However, it does not explicitly contrast with alternatives like stop+start or when not to use this tool. The context of audit logging provides some guidance.

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

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

With no annotations, the description carries full burden. It explicitly states it is a read operation (starts with [READ]), describes the inspection process, and notes no destructive effects. It covers exit code interpretation and log attachment.

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

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

The description is front-loaded with a summary sentence, followed by detailed behavior and parameter list. It is well-structured but slightly verbose in the middle paragraph; still efficient given the complexity.

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 explains input parameters and behavior sufficiently. It mentions output includes ranking numbers and cause/action, but does not detail the exact output structure. Given no output schema, this is adequate for an RCA tool.

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

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

Schema description coverage is 0%, but the description includes an 'Args' section that explains all four parameters: restart_threshold (default), containers (injected rows), logs_by_id (optional logs), and target (target name). 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 tool's verb 'Find' and resource 'crash-looping containers', and explains its RCA purpose. It distinguishes from sibling tools like list_containers and inspect_container by focusing on root cause analysis of restart loops.

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 when to use (for crash-loop analysis) and how to invoke (pass containers or target). It mentions the threshold parameter but does not explicitly state when not to use or 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?

No annotations are provided, so the description carries the burden. It signals read-only with '[READ]' and notes the requirement of a portainer target. It does not discuss side effects, auth, or rate limits, but for a read tool this is 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 very concise: one line for purpose, one line for requirement, and two lines for parameters. No redundant information; front-loaded with the key action.

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

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

Given no output schema, the description mentions what details are returned (env, entrypoint, resource control) and the configuration requirement. It could hint at the format (e.g., JSON), but is sufficiently complete for a read tool.

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

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

With schema coverage at 0%, the description adds essential meaning: 'stack_id: Portainer stack id' and 'target: Target name from config; omit for the default'. This compensates well for the empty 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?

Description starts with '[READ] One Portainer stack in detail (env, entrypoint, resource control)', clearly stating it retrieves detailed information for a single stack. It distinguishes from sibling tools like list_stacks (list) and recreate_stack (modify).

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 'Requires a portainer target' and explains the target parameter. However, it does not explicitly state when to use this tool versus alternatives (e.g., list_stacks for overview) or provide exclusions.

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

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

The description includes a '[WRITE][risk=medium]' tag and states the action is to start a stopped container. While it discloses the write nature and risk level, it lacks details on side effects, failure modes, or dependencies. Since no annotations are provided, the description carries the full burden and could be more thorough.

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 succinct, using a docstring format with clear sections. It front-loads the main action and risk level, then quickly covers parameters in a list. Every sentence serves a purpose, with no extraneous text.

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

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

The tool has three parameters and no output schema, and the description covers the action and all parameters adequately. It could mention prerequisites (e.g., container must be stopped) or what happens if already running, but overall it provides enough context for correct 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?

Despite the schema having 0% description coverage, the description provides clear meanings for all three parameters: container_id as 'Container id or name', dry_run as 'If True, preview without starting', and target as 'Target name from config; omit for the default'. This adds significant value beyond the schema's type 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 'Start a stopped container' providing a specific verb and resource. It distinguishes itself from sibling tools like stop_container by noting it is the inverse. The purpose is unambiguous.

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

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

The description gives guidance on using dry_run for preview and explains the target parameter as omitting for default. However, it does not explicitly contrast with other container tools like restart_container or update_container, leaving some ambiguity about when to use this over 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?

Discloses mutating behavior (WRITE), risk level, undo recording, and graceful stop with timeout. However, no permissions or side effects discussed; annotations are absent so description bears full burden.

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?

Very concise: two paragraphs, first stating purpose and key behavior, second listing parameters with defaults. Every sentence is informative, 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?

For a simple stop tool with 4 parameters and no output schema, the description covers all needed: action, behavior, args, usage tips. No gaps remain.

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

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

Schema coverage is 0%, but description explains all four parameters: container_id (id or name), timeout (seconds, default 10), dry_run (preview), target (from config). Adds essential meaning beyond 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?

Description uses specific verb 'stop' and resource 'container', and contrasts with 'start' (inverse). It clearly distinguishes from sibling tools like start_container, remove_container, restart_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?

Describes when to use dry_run for preview, and mentions undo recording. Provides clear context but does not explicitly state when not to use or list alternatives beyond the inverse.

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 '[READ]' prefix indicates read-only behavior, which is good. However, with no annotations, the description should disclose more traits (e.g., auth, performance impact). No additional behavioral details are provided.

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?

Extremely concise: two sentences plus an arg list. Front-loaded with the '[READ]' tag. Every word adds value, no 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?

For a simple disk-usage tool with one optional parameter, the description covers the main purpose and parameter usage. Lacks details about output format or units, but overall sufficient given the tool's simplicity.

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 has 0% coverage, so description must compensate. It explains the 'target' parameter as coming from config and defaults to null, adding meaning beyond the schema's title and type. However, no formatting or constraints specified.

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 provides a disk-usage breakdown for images, containers, volumes, and build cache, with a read-only indicator. It distinguishes from siblings like image_disk_usage by listing multiple categories, but does not explicitly differentiate itself.

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 on when to use this tool versus alternatives such as image_disk_usage or prune tools. The description only states what it does, not context 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?

No annotations provided, so description carries full burden. It discloses the tool is read-only, describes the return envelope with truncation behavior, and explains how to handle truncation. This is good transparency for a read operation.

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

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

Two paragraphs: first states purpose and arguments, second describes return envelope. No redundant sentences, front-loaded with '[READ]' and purpose. Every sentence adds value.

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

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

With 3 parameters and no output schema, the description adequately covers inputs and output format. It explains truncation. Missing contextual details like event structure or example, but 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?

Schema coverage is 0%, so description must explain all parameters. It does so thoroughly: since (range 1..86400, default 3600), event_type (list of allowed values), target (default omitted). Each parameter gets clear semantics beyond schema names.

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 retrieves 'recent daemon events over the last N seconds, rolled up by type+action', with a '[READ]' prefix. This distinguishes it from sibling tools like system_info or container_logs, though the exact meaning of 'rolled up' could be more 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?

No explicit guidance on when to use this tool vs alternatives (e.g., system_info, container_logs). The description only explains parameters without contextualizing the tool's role among siblings.

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

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

The description marks the tool as [READ], indicating it is non-destructive. With no annotations, this simple indication is adequate but does not disclose potential side effects, permission requirements, or performance characteristics.

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

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

The description is extremely concise with two sentences, front-loading the main purpose. Every word serves a purpose, and the structure is 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?

Given the single optional parameter and no output schema, the description covers the basics but lacks detail on the return structure or format. The listed fields (counts, driver, kernel, resources) are vague, leaving some ambiguity about what exactly is returned.

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 the 'target' parameter beyond the schema: 'Target name from config; omit for the default.' Since the schema provides no description (0% coverage), this added context is valuable and clarifies 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 clearly states what the tool does: returns daemon info including container/image counts, storage driver, kernel, and resources. However, it does not explicitly differentiate from siblings like system_version or system_df, which are more specific.

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 (e.g., system_version, system_df). The description does not specify contexts or exclusions.

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

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

No annotations provided, so the description carries the burden. It indicates read-only via '[READ]' and lists returned components. However, it does not disclose potential behaviors like authentication needs, rate limits, or error cases. For a simple read tool, this is minimally 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 brief, front-loaded with '[READ]', and structured into a purpose sentence followed by parameter documentation. It is efficient but could be slightly more structured (e.g., using bullet points).

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

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

Given no output schema, the description does not explain return values or example output. For a simple version query, it is adequate but could be more complete by noting the format or scope (e.g., Docker Engine vs CLI version).

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

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

The input schema has 0% description coverage, but the description explains the 'target' parameter's purpose ('Target name from config; omit for the default'), adding meaning beyond the schema fields. This clarifies usage and default behavior.

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 it reads Docker version details, including API version, Go version, and components. The prefix '[READ]' clarifies the operation type. It distinguishes from sibling tools like 'system_info' by focusing on version details, though not explicitly differentiating.

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 on when to use this tool versus alternatives. Lacks any context about prerequisites, when not to use, or comparisons with sibling tools like 'system_info' or 'overview'.

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

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

With no annotations provided, the description carries the full burden. It discloses the write nature with '[WRITE][risk=medium]', mentions auditing, and notes the single-use token constraint. However, it does not detail failure modes or idempotency.

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, front-loads the purpose, and organizes details in a clear Args section. 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 explains parameters and behavior well but omits the return value and error conditions. Given the tool's complexity (3 params, no output schema), the missing return information leaves a gap in completeness.

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

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

Schema description coverage is 0%, but the description's Args section explains all three parameters: undo_id source, dry_run preview behavior, and target passthrough. This adds significant meaning beyond the schema's type 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 the tool's purpose: 'Apply a recorded undo by dispatching its inverse tool.' It specifies the action (apply) and the resource (recorded undo), distinguishing it from the sibling 'undo_list' which lists undos.

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 usage context such as passing dry_run=True to preview and notes that a token can only be applied once. It implicitly contrasts with undo_list but does not explicitly state when not to use or provide alternative tools.

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

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

With no annotations, the description carries full burden and excels. It declares the tool as read-only ('[READ]'), details the truncated behavior with precise explanation ('measured, not guessed'), and explains the effectVerified field's implications for probable vs. confirmed changes.

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, starting with a clear purpose, then explaining the return format, followed by parameter details. Every sentence is informative 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?

Despite no output schema, the description fully documents the return structure (undos, returned, limit, truncated) and the nuance of effectVerified. All parameters are explained, and the tool's role in the undo workflow 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?

Schema coverage is 0%, but the description fully compensates. It specifies limit's default (50) and cap (500), and explains target is unused but included for uniformity. This adds significant 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 '[READ] List recorded, not-yet-applied undo tokens (most recent first).' It specifies the verb (list), resource (undo tokens), and scope (recorded, not-yet-applied), distinguishing it from sibling tools like list_containers or undo_apply.

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 primary use case: listing undo tokens for applying with undo_apply. It also provides guidance on interpreting the truncated field and suggests re-running with a higher limit. However, it does not explicitly state when not to use this tool versus 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?

Discloses it's a write operation with medium risk, captures prior limits, and supports dry_run. No mention of container state requirements, side effects like restart, or authentication needs. Moderate transparency for mutation tool without annotations.

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?

Concise two-sentence purpose followed by parameter list. Front-loaded with key info. Slight redundancy but overall 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?

Covers main behavioral aspects (undo, dry_run) and parameter details. Lacks explanation of return value or whether changes are synchronous. With 4 params, nested object, and no output schema, additional context on response would improve completeness.

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

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

Schema coverage is 0%, but description adds meaning by listing allowed resource keys (Memory, MemorySwap, etc.) and explaining dry_run and target. Container_id and target are clearly described. Compensates well for 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?

Clearly states it updates a container's resource limits and captures prior limits for undo. Verb 'update' and resource 'container's resource limits' are specific. Distinguishes from sibling lifecycle tools like start_container, stop_container, etc.

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?

Explains it is for updating resource limits and capturing prior limits for undo. Mentions dry_run for preview. Does not explicitly state when not to use, but context implies it's for resource modifications, not other container operations.

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