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 full burden and does so thoroughly: it declares the operation as read-only, states that findings are reported in rank order, and explains exactly which signal types are included and how specific events are classified.

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 summary line is front-loaded, and the longer event discussions earn their place by preventing misinterpretation of edge cases. The Args block is clean and maps directly to the schema.

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 there is no output schema and no annotations, the description provides a complete picture: what the tool reads, how it filters, when to call it, what edge cases to expect, and how results should be reported. Nothing critical is missing for an agent to select and invoke it correctly.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining each parameter's meaning, constraints, and default: 'Recent warning-or-worse events to correlate, 1-1000 (default 200)', 'Ignore events older than this many hours, 1-720 (default 24)', and target as an optional config-based 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 opening sentence states a specific verb and resource: 'Problems with the engine itself, ranked worst first, in one call.' It clearly separates this tool from the host, VM, and storage RCA siblings by scoping events to those naming no host, VM, or storage domain.

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 explicit when-to-use guidance: 'call this first for "is anything wrong"' and explains that these alerts 'appear in no other diagnosis.' It also clarifies edge cases, such as why event 10803 belongs here and why event 2024 stays low.

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 behavioral burden and does so thoroughly. It discloses result fields (signal, cause, action, rank), ordering requirements, edge cases (in-progress vs failed, alert 9000, event 10802), incomplete-candidate behavior, and the time-only pairing semantics of relatedVmEvents. This goes far beyond a basic 'gets host health' statement.

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?

Although long, the description is densely informative and every sentence earns its place. It front-loads the primary purpose, then systematically covers result shape, interpretation rules, edge cases, and parameter semantics without filler. The length is justified by the tool's complexity and lack of an output schema.

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

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

Given the tool's complexity, the absence of annotations, and the absence of an output schema, the description is complete enough for correct invocation and interpretation. It defines finding fields, ranking, special-case semantics, parameter effects, and how to report candidate VMs, leaving no major gap for an agent deciding whether and how to call it.

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

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

The input schema provides only names, types, defaults, and no descriptions, so the description's Args section is essential. It explains the meaning and ranges of events_limit and events_window_hours, notes side effects like eventsOutsideWindow, and clarifies that target refers to the engine target from config. All three parameters receive meaningful semantic context.

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 purpose: it identifies what needs attention on KVM hosts, ranked worst first, in one call. It specifies the resource (KVM hosts), the output orientation (ranked findings), and the combined data sources (status, reinstall/update flags, recent events), which distinguishes it from single-purpose siblings like host_get and event_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 gives explicit interpretation rules and routes to a sibling: VM-level failures are said to be covered by vm_health_rca, and event-10802 guest-agent failures are explicitly excluded from being treated as host problems. It also tells the agent when not to restate a finding as 'this host is failing' and how to treat in-progress hosts and informational alert 9000, giving clear when/when-not guidance.

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

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

No annotations are provided, so the description carries the burden. 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 full burden. It is exceptionally transparent: declares it's a read operation, explains severity logic in detail, covers edge cases (unset thresholds, over-commit), states what events are attached, and what is skipped. It also tells the agent how to interpret signals (report in rank order, quote signal). No behavioral surprise is left undisclosed.

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 detailed but every sentence earns its place. It is structured logically: purpose first, then severity conditions, edge cases, and finally parameter explanations. No fluff or redundancy. The information density is high while remaining readable.

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

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

Given the tool's complexity (RCA with multiple severity levels, edge cases, and return behavior), the description covers everything an agent needs to know: what it returns (ranked findings), how to interpret signals, what is skipped, and how to handle exceptions. Since there is no output schema, the description adequately explains the return format. Nothing critical is missing.

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

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

The description includes an 'Args' section that fully explains each parameter: events_limit (range 1-1000, default 200), events_window_hours (range 1-720, default 24), and target (engine target name, omit for default). This goes beyond the schema's bare titles and defaults, providing complete semantics.

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: lists storage-domain problems ranked worst first, in one call. It specifies the resource (storage domains) and the action (list problems ranked). It also differentiates from sibling tools by its focus on capacity RCA rather than listing or getting domains. The severity definitions add clarity.

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

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

The description gives clear context on when to use it: when free space is below critical or warning thresholds, or when domains are inactive/unknown. It explicitly states what it skips (unattached domains) and how it handles edge cases like unset thresholds and over-commit. However, it does not name alternative tools or explicitly say 'use this instead of X', though the behavior is well-defined.

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.