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

No annotations are provided, so the description must carry the behavioral burden. It includes the [READ] marker, implying a safe read operation, and lists the data fields. However, it does not disclose potential errors, authentication requirements, or any side effects—though for a simple list tool these may be minimal. It adds some context but not rich behavioral detail.

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

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

The description is extremely concise and front-loaded: the [READ] marker and purpose appear first, followed by a clearly separated Args section. Every sentence adds value, with no filler.

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

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

For a simple list tool with two optional parameters and no output schema, the description is sufficient. It states what is returned, how to limit results, and how to specify a target. It lacks details on ordering or any additional filters, but these are not critical for a basic enumeration tool.

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

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

The schema provides only types and defaults, with no descriptions. The description compensates by explaining the limit range (1-1000, default 100) and the target's meaning (engine target from config, omit for default). This adds meaningful semantics beyond the schema, though it does not elaborate on the format or constraints 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 clusters and specifies the fields returned (compatibility version, CPU type, memory over-commit policy). It is distinct from sibling tools like datacenter_list and host_list, so 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 provides no guidance on when to use this tool versus alternatives. It does not mention that this is the appropriate tool for enumerating clusters, nor does it suggest other tools for different scenarios (e.g., host_list for hosts). No exclusions or alternative references are given.

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

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

With no annotations provided, the description carries the behavioral disclosure burden itself. It states [READ], indicating a non-mutating operation, and explicitly discloses the `truncated` signal when more rows exist. It does not cover every edge case (e.g., error behavior or ordering), but for a simple read/list tool it adds meaningful behavioral context.

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

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

The description is compact and front-loaded: the read marker and returned content appear first, followed by a tight two-item Args list. Every sentence carries information with no filler or repetition.

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

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

For a tool with two optional parameters, no output schema, and no annotations, the description covers the parameters and key output indicators (status, compat version, truncated). It is adequate to call correctly, though it stops short of fully specifying the response shape or explicit use cases.

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 fully compensates by explaining both parameters: `limit` gets a row count range, default, and the `truncated` consequence; `target` gets source and default behavior. This adds substantial meaning beyond the bare integer/string schema types.

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 resource as data centers and the returned content (status, compat version) with a [READ] marker, making it distinguishable from list tools for clusters, hosts, VMs, and storage domains. It lacks an explicit 'List all data centers' verb phrase, but the intent is not ambiguous.

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 offers no explicit when-to-use versus alternatives guidance, no exclusions, and no mention of sibling tools. Usage context is only implied by the tool name and the resource name; the parameter notes are about arguments, not tool selection.

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

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

With no annotations, the description carries the behavioral burden. It discloses what it reads (health check, version, clock, counts, specific event types), how it reports (rank order, quoting signal), and that it is a read operation (prefixed with [READ]). It doesn't mention side effects, permissions, or error conditions, but for a read-only diagnostic these are minor omissions given the detail 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?

The description is well-structured: a crisp purpose line, a detailed but scoped explanation of what it reads, a usage directive, then parameter details. Every sentence adds value, and the key purpose is front-loaded. It is long but not padded; the structure aids parsing.

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 having no output schema, the description explains what the tool returns (findings in rank order with signal quotes) and why it's needed (unique alerts). All parameters are covered, and the usage priority is stated. For a complex RCA tool, this is complete enough 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?

Schema description coverage is 0%, so the description must compensate, and it does thoroughly. Each parameter is explained with purpose, range, and default: events_limit for 'correlation', events_window_hours for 'ignore events older', and target for choosing from config. This far exceeds the schema's bare type/default info.

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

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

The description opens with a specific verb and resource: 'Problems with the engine itself' and 'Reads the engine's health check...' It clearly distinguishes from siblings like host_health_rca and vm_health_rca by focusing on engine-specific alerts that 'appear in no other diagnosis.' The scope is unambiguous and the tool's unique role is 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?

It gives explicit when-to-use guidance: 'call this first for "is anything wrong"' and explains that its alerts are exclusive ('appear in no other diagnosis'). This sets priority and differentiates from other RCA tools, even though it doesn't name them directly. The instruction to report in rank order also guides invocation.

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

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

With no annotations, the description carries the full burden and does so thoroughly: it discloses ordering inversion when using after_index, truncation semantics, scanTruncated caveats, and redaction of SSO session IDs. The [READ] marker also signals non-mutating behavior.

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

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

The description is dense but well organized: a one-line purpose, a short usage paragraph for the non-obvious cursor behavior, then a terse Args list. Every sentence adds needed operational detail without filler.

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

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

Despite having no output schema and no annotations, the description is complete enough for an agent to call the tool correctly. It defines all parameters, explains repeated-call pagination semantics, and warns about missing events and redacted fields.

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

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

Schema description coverage is 0%, so the description must explain every parameter, and it does. The Args block covers all six parameters with ranges, defaults, enum values, and combinability constraints such as page not being combinable with since_minutes or after_index.

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 operation as reading engine events, the resource involved, and the key filtering/ordering behavior: severity threshold and newest-first ordering. This distinguishes it from the sibling tools, none of which list engine events.

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

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

The description gives concrete usage guidance for following new events with after_index, using since_minutes for recent events, and using page for older pages, including an explicit incompatibility between page and the other modes. It does not name alternative tools, but the provided context is sufficient given the sibling list.

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

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

No annotations are provided, so the description carries the full burden. The '[READ]' prefix signals a read operation, but the description does not disclose behavior such as error cases, whether the host must exist, what fields are returned, or any side effects. It adds only the scoping to a single host by id.

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 short and front-loaded with the '[READ]' marker and the core purpose. The Args section is compact and useful. It earns its place, though the 'see host_list' reference is slightly terse.

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 get-by-id tool with two parameters and no output schema, the description is mostly adequate. It lacks details about return value shape, error behavior, and any prerequisites, but the tool's simplicity and the sibling list help an agent infer context. A bit more behavioral context would make it complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains host_id as 'Host id' and target as 'Engine target name from config; omit to use the default', which adds meaning beyond the schema's bare titles. However, it does not explain how host_id is formatted or how target selection works in practice.

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

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

The description states a specific verb ('get') and resource ('one KVM host by id'), and references host_list as the sibling for listing. It is clear what the tool does, though it does not explicitly differentiate from other get-style siblings like storage_domain_get or vm_get beyond the resource name.

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

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

The description implies usage by saying 'see host_list' and by naming the host_id argument, but it does not explicitly state when to use this tool versus alternatives. It provides minimal context: use this to fetch a single host by id, while host_list is for listing. No exclusions or alternative conditions are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it excels. It explicitly states that hosts being installed/rebooted are 'reported as in progress, not failed', and that alert 9000 is 'informational on hosts without fencing hardware.' It also instructs to 'Report findings in rank order and quote their signal,' covering output expectations. These are non-obvious behaviors that an agent must know to interpret results correctly.

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

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

The description is efficiently structured: a one-sentence purpose statement, a compact behavioral note, and a concise parameter list. Every sentence adds value; there is no fluff. The key purpose is front-loaded, and the parameter details are clearly separated. It is appropriately sized for the tool's 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 is complete for an agent to use the tool correctly. It defines the output contract (each finding has signal, cause, action, rank), explains special cases (in-progress vs failed, informational alert), and documents all parameters. Although there is no output schema, the description provides sufficient detail on return semantics. It also mentions 'eventsOutsideWindow' implicitly, covering the window behavior. Nothing essential is missing.

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

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

Schema description coverage is 0%, so the description must fully compensate. It does: the 'Args' block explains each parameter with its range, default, and purpose (e.g., 'events_limit: Recent warning-or-worse events to correlate, 1-1000 (default 200)'). This adds significant semantic meaning beyond the bare schema types and defaults, making the tool safely callable.

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: 'What needs attention on KVM hosts, ranked worst first, in one call.' It names the resource (KVM hosts), the verb (needs attention), and the ranking. It distinguishes itself from sibling tools like host_list (simple listing) and host_get (single host) by emphasizing the composite, prioritized RCA output. It also stands apart from other RCA tools (engine, storage, vm) by explicitly scoping to KVM hosts.

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 when to use this tool: when you need a consolidated health assessment of KVM hosts in one call, combining status, events, and reinstall/update flags. It does not explicitly name alternatives or exclusions, but the 'in one call' phrasing and the composite nature strongly signal it's the go-to for host-level RCA. Given the presence of sibling RCA tools, a more explicit comparison would have pushed this to 5.

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 discloses a key behavioral trait: 'A field the engine did not report is null, never 0.' It also discloses pagination/truncation behavior via the limit parameter description. It doesn't mention auth or rate limits, but for a read-only list tool, the disclosed null semantics and truncation behavior are valuable and go beyond the schema.

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

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

The description is compact and front-loaded: the purpose is in the first line, the alternative tool is named early, and the Args section is terse but informative. Every sentence earns its place; no filler.

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

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

For a list tool with 3 optional parameters and no output schema, the description covers the key semantics: null handling, truncation, search syntax, and target selection. It doesn't describe the output structure, but since there is no output schema, a brief note on what fields are returned is present in the first line. It is complete enough for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does: it explains limit's range and default, defines search as 'Engine query language' with examples, and explains target as 'Engine target name from config; omit to use the default.' This adds meaning beyond the bare schema types.

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

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

The description opens with a clear verb and resource: '[READ] KVM hosts with status, SPM role, memory and VM counts.' It distinguishes itself from sibling host_health_rca by explicitly saying that tool is for 'what is wrong with my hosts.' This is specific and differentiates from 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?

The description explicitly says when to use this tool vs alternatives: 'For "what is wrong with my hosts" use host_health_rca instead of reading this list yourself.' It also explains the search parameter with examples, giving clear context for when to use it. This is explicit routing 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?

The [READ] tag clearly signals a non-mutating operation, which is useful since no annotations are provided. The description also conveys that jobs are long-running operations and that results include status and duration. However, it does not disclose return structure details beyond those two fields, pagination behavior beyond limit, or error/edge-case behavior.

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

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

The description is compact and front-loaded with the read intent, followed by a clean parameter list. Every line adds useful information and there is no redundant or filler 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?

All parameters are explained and the core purpose is clear, making the tool callable. But with no output schema and no annotations, the description only minimally describes returned fields and does not explain result ordering, required permissions, or how to route to sibling tools. The gaps are not severe for a simple read-only list, but the description is not fully self-sufficient.

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

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

With 0% schema description coverage, the description fully compensates by documenting all three parameters. It gives a range and default for limit, enumerates the valid status values, and explains that target comes from configuration and defaults when omitted. This is strong semantic value beyond the bare schema types.

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 identifies Engine jobs as the resource and states that the output includes status and duration. It is more specific than generic 'list jobs' and is distinguishable from sibling list tools like vm_list or host_list. The lack of an explicit 'list' verb is minor because the tool name and [READ] marker make the operation clear.

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

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

The description provides no guidance about when to use job_list instead of related tools such as event_list or undo_list. It does not state any exclusions, prerequisites, or alternative tool suggestions. An agent must infer usage context from the name alone.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that it is a read operation (prefixed '[READ]'), explains the ranking logic (critical/medium/high thresholds), specifies exclusions (unattached domains), and notes that findings are reported in rank order with their signals. This is substantial, though it does not mention potential rate limits or authentication requirements.

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 clear one-liner, followed by a compact explanation of the ranking logic and then a structured Args list. It is a bit long, but every sentence adds value; no fluff or repetition. The structure aids scannability.

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

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

The description covers the tool's purpose, ranking criteria, input parameters, exclusions, and reporting style. Without an output schema, it does not detail the exact return format, but it states that findings are ranked and quoted, which is sufficient for an agent to call it correctly. The context is complete for a read-only 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?

The schema provides zero descriptions for its three parameters, but the description's 'Args' section fully documents each one: events_limit (range and default), events_window_hours (range and default), and target (with omission guidance). This completely compensates for the schema gap and adds clarity beyond the bare property 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 opens with a precise statement: 'Storage-domain problems ranked worst first, in one call.' It clearly identifies the verb (rank) and the resource (storage-domain problems), and goes on to explain the ranking criteria in detail, distinguishing it from simple list/get tools like storage_domain_list.

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 tool's analytical nature and its input parameters, but it never explicitly contrasts it with alternatives such as storage_domain_list or event_list. The use case is implied by the RCA context, but no direct guidance is given on when to prefer this over 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?

There are no annotations, so the description carries the burden, and it does lead with '[READ]', signaling a non-mutating operation. It also adds the data-center-scoped status nuance, but it does not describe return format, failure behavior, authentication needs, or other side effects. This is adequate but minimal for an unannotated 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 compact, starts with the purpose, and uses a tightly formatted Args block. Every sentence is necessary and no redundant phrasing is present.

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

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

For a simple single-record fetch tool with two parameters and no output schema, this description is essentially complete. The only minor gap is absence of any statement about what fields are returned or error conditions, but the low complexity and read-only nature make this acceptable.

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

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

The schema provides 0% description coverage, so the description must compensate, and it does explain both parameters. 'domain_id' is clarified as a storage domain id and cross-referenced to storage_domain_list; 'target' is explained as an Engine target name from config, with the default behavior noted. This adds meaningful guidance beyond the bare schema.

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

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

The description clearly states the verb ('get'), the resource ('storage domain'), the selector ('by id'), and a specific qualifier ('data-center-scoped status'). This differentiates it from the sibling storage_domain_list, which lists many domains, and the 'One storage domain by id' phrasing makes the selection criterion explicit.

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

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

The usage context is clear: you fetch a single storage domain by id, and you can obtain an id via storage_domain_list. However, it never explicitly contrasts when to use this vs alternatives or states exclusions, so the guidance is implied rather than stated.

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

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

No annotations are provided, so the description carries full behavioral disclosure. It explicitly explains the status behavior (null when data center read fails, with statusErrors), and mentions the `truncated` flag for pagination. This adds valuable context beyond the bare schema.

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 tightly written with no filler. It front-loads the operation and result, then devotes exactly two sentences to the parameters. Every sentence 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?

Given a list tool with two parameters and no output schema, the description covers the essential behavioral nuances (status source, null handling, truncation). It does not describe the output structure, but that is not required without an output schema, and the tool is simple enough that the agent can call it correctly.

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

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

Schema description coverage is 0%, but the description fully compensates. It explains `limit` (range, default, and that `truncated` indicates more rows) and `target` (engine target from config, omit for default). This is far richer than the bare schema types 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 opens with '[READ] Storage domains with status and capacity', naming the exact resource and operation. It distinguishes itself from the sibling storage_domain_get by implying a list operation, and adds specific detail (free, used, committed bytes and %) that clarifies the return scope.

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 a list operation but does not explicitly contrast it with storage_domain_get or other siblings. There is no when-to-use or when-not-to-use guidance, leaving the agent to infer that it is for listing domains rather than fetching a single one.

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

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

With no annotations, the description carries the full burden and does so well. It openly marks the operation as '[WRITE][risk=medium]', explains that the inverse tool runs under its own governance and risk tier, warns that a token can only be applied once, and mentions dry_run to preview without executing. This goes beyond a simple 'apply' and discloses key behavioral traits.

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

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

The description is well-structured with a clear summary line, a brief paragraph of important caveats, and an Args list. Every sentence adds value, and it is appropriately front-loaded with the [WRITE] and risk indicator.

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 purpose, parameters, and behavior comprehensively. However, it does not mention what the tool returns (e.g., the inverse tool's result or a success/failure status). With no output schema, a brief note on return value would make it fully complete.

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

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

The schema provides only titles with 0% description coverage, so the description must explain each parameter. It does: undo_id is sourced from undo_list or _undo_id, dry_run previews the inverse call, and target is passed through conditionally. This adds substantial 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's purpose: 'Apply a recorded undo by dispatching its inverse tool.' This distinguishes it from sibling tool undo_list, which lists recorded undos, and other write tools. The verb and resource are specific, leaving no ambiguity.

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

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

The description provides usage context by noting the undo_id source ('from undo_list or an _undo_id in a write result') and the dry_run preview option. It does not explicitly name alternatives or exclusions, but the context makes it clear when to use this tool versus listing undos.

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 takes full responsibility and reveals key behaviors: it is a read ([READ]), uses a truncated detection mechanism (one extra row), explains the effectVerified flag meaning, and notes that the target parameter is unused. This goes beyond simple listing.

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 header, entry details, and an args section. It is informative without being overly verbose, though the explanation of effectVerified could be slightly condensed.

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

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

Given the lack of output schema and two parameters, the description covers all essential aspects: purpose, parameters, usage, and behavioral traits. It mentions the fields in each entry (undoId, original tool, etc.), making it 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 coverage is 0%, so the description compensates by explaining both parameters: limit with default and cap (50–500), and target as unused for CLI uniformity. This adds meaning beyond the schema's type/default information.

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

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

The description clearly states the tool's purpose: listing undo tokens that are recorded but not yet applied, in order (most recent first). It specifies it is a read operation and distinguishes it from sibling tools like 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 tells users to use the returned undoId with undo_apply and explains the effectVerified flag for safe usage. However, it does not explicitly mention when to avoid using this tool or provide comparisons to other list tools.

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

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

With no annotations, the description must carry the behavioral burden. It includes '[READ]' which signals a non-mutating operation, and states it retrieves one VM. However, it does not mention error behavior (e.g., not found), permissions, or any side effects. The read hint is valuable but limited; it adds some transparency but not rich behavioral context.

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

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

The description is concise and well-structured. It front-loads the purpose and uses an Args section for parameters. Every sentence adds value without redundancy. The format is clean and scannable, making it easy for an agent to parse.

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

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

Given the simplicity of the tool (single fetch by id) and no output schema, the description is adequate but not complete. It covers the parameters and the read nature, but does not specify the return format, error handling (e.g., missing VM), or pagination (not applicable). For a basic get tool, this is acceptable, but additional notes on error cases 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?

The schema has 0% description coverage, so the description must explain parameters. It does so: vm_id is 'VM id' (minimal but accurate) and target is described as 'Engine target name from config; omit to use the default.' This adds meaning beyond the schema by explaining the source and default behavior of target. The vm_id explanation is trivial but acceptable given its name.

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

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

The description states a clear verb+resource: 'One VM by id'. It distinguishes itself from vm_list by explicitly scoping to a single VM and referencing vm_list for the listing case. This makes the tool's purpose unambiguous and differentiates it from 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?

The description indicates when to use this tool: to retrieve one VM by id, and points to vm_list for the alternative (listing). While it does not explicitly list when not to use it, the reference to vm_list provides a clear contrast. It is not exhaustive but sufficient for an agent to choose correctly.

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

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

With no annotations, the description carries the full burden. It discloses read-only behavior via '[READ]', explains the ranking logic, supersession rules, and the meaning of 'Down VMs without HA are normal', which prevents misinterpretation. It does not cover auth or rate limits, but for a read-only RCA 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 structured with a leading summary, a severity explanation, and an args section. It is longer than minimal but every sentence adds value, and the structure aids readability. The front-loaded summary allows quick comprehension.

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

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

For a tool with 3 optional parameters, no output schema, and no annotations, the description fully explains the expected output (ranked findings, quoted signals) and the interpretation logic. It is complete enough for an agent to invoke correctly 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 description provides detailed semantics for all three parameters that the schema only lists as names. It explains ranges, defaults, and the effect of each (e.g., events_window_hours controls ignored events and counts them in eventsOutsideWindow). This is high-value beyond the schema, especially given the 0% schema description coverage.

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

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

States a specific verb and resource ('VM problems ranked worst first') and clearly distinguishes it from sibling tools like storage_capacity_rca, host_health_rca, and engine_health_rca by scoping to VMs and providing a ranking. The '[READ]' prefix immediately signals a non-mutating operation.

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 names an alternative (storage_capacity_rca) for a specific scenario (storage I/O errors or full domain), and explains severity levels that guide when to investigate. It does not explicitly contrast with host_health_rca or engine_health_rca, but the VM-specific scope is clear, and the description implies its usage for VM health triage.

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

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

Since no annotations are provided, the description carries the full burden. The [READ] prefix discloses read-only behavior, and the description goes beyond the schema by explaining the 1-1000 limit range, the default of 100, and the `truncated` indicator that signals pagination or response limits. It does not mention auth, rate limits, or performance, but for a simple list operation the key behavioral traits are covered.

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 and well-structured: a one-line purpose statement followed by a clean, aligned argument list with defaults and examples. Every sentence adds value, and no unnecessary detail is included.

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

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

For a read-only list tool with no output schema, the description states the resource, the fields returned, the pagination behavior via `truncated`, and all parameter semantics. It omits minor aspects like ordering, error behavior, or explicit output shape, but the essential calling contract is covered.

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 zero description coverage, but the description fully compensates: it gives the limit range and default, explains the `truncated` flag, illustrates the search engine query language with concrete examples, and describes what the target parameter means and its default behavior. This is far richer than 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 identifies the operation (reading VMs) and enumerates the returned fields (status, host, vCPUs, memory, HA flag), so an agent knows what it physically does. It differentiates from vm_get and vm_stats by indicating a plural list of VMs, but it does not explicitly name alternatives or contrast with siblings, so it stops short of a full 5.

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

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

The description contains no guidance on when to select vm_list over its sibling tools such as vm_get, vm_stats, or host_list. It only explains the individual parameters and provides search examples, but never states the intended use case, exclusions, or when an alternative is more appropriate.

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

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

No annotations are provided, so the description carries the full burden. It includes a '[READ]' marker implying read-only, but discloses nothing about authentication, rate limits, side effects, or error behavior. This is a significant gap for a tool that likely has operational implications.

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

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

The description is concise, front-loaded with the purpose, and uses a clean structure with an args section. Every sentence contributes value, and there is no filler.

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

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

The description mentions the returned metrics (memory, CPU %, network, disk) but lacks usage guidance and behavioral context. Without annotations or an output schema, an agent has limited understanding of when to use this tool or what errors or edge cases to expect.

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

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

The description gives brief explanations for both parameters: vm_id is 'VM id' (minimal, tautological) and target is 'Engine target name from config; omit to use the default' (adds config context and default behavior). Since schema coverage is 0%, this partially compensates, but vm_id could be more descriptive.

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 a VM's current statistics (memory, CPU %, network, disk) with units, using a specific verb and resource. It doesn't explicitly differentiate from siblings like vm_get or vm_health_rca, but 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?

No guidance is provided on when to use this tool versus alternatives such as vm_get, vm_list, or vm_health_rca. The agent is left to infer the appropriate context, and no exclusions or conditions are mentioned.

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