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

Declares [READ] clearly and describes classification behavior, but without annotations, it would benefit from explicitly stating it does not modify state.

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?

Description is somewhat concise but includes an Args section that redundantly lists parameters already in the schema, wasting space.

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?

Adequately describes output categories and sample messages; no output schema exists, so description sufficiently covers expectations.

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?

Provides clear, meaningful descriptions for both parameters (limit and target) beyond the schema, including defaults and usage hints.

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

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

Description explicitly states it classifies failed/skipped backup runs by job and lists specific categories (vdi-chain, quiesce, etc.), clearly distinguishing it from sibling tools like backup_log_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?

Implied usage via 'Classify failed / skipped backup runs' but does not explicitly state when to use this tool versus alternatives like backup_job_list or vm_health_rca.

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

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

No annotations provided, but the description clearly indicates read-only behavior with '[READ]' and fully specifies the return format, including pagination details.

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

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

The description is concise (5 sentences), front-loaded with the core purpose in brackets, and structured logically with return format and parameters.

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

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

For a simple list tool with two parameters and no output schema, the description covers return format and parameter semantics adequately, though it could mention error handling or job object structure.

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

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

Despite 0% schema description coverage, the description adds meaningful explanations for both parameters: limit (max jobs, default 200) and target (Xen Orchestra target, default omitted).

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 begins with '[READ] List VM backup jobs (id, name, mode)', which is a specific verb and resource, clearly distinguishing it from siblings like vm_list or backup_log_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 mentions pagination behavior but lacks explicit guidance on when to use this tool versus alternatives like backup_log_list or backup_failure_rca.

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 the return structure and explains truncation measurement (requesting one extra record). This tells the agent that truncated=true means older runs exist, a non-obvious behavioral detail. It does not mention rate limits, data freshness, or authentication, but for a read-only log tool the core behavior is well 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 front-loaded with purpose ('[READ] Recent backup run logs'), then immediately gives output structure, then truncation explanation, then parameter list. Every sentence adds value with no redundancy. It is compact and well-organized for an AI 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 low complexity (2 optional parameters, no required, no output schema), the description provides a clear output structure, parameter explanations, and critical truncation behavior. It does not describe possible errors (e.g., invalid target) or the internal format of 'logs' array, but for a straightforward list tool this is largely sufficient. The missing error handling and return structure details prevent a perfect score.

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 fully explains both parameters: 'limit: Max recent log entries to return (default 50)' and 'target: Xen Orchestra target name from config; omit for the default.' This provides semantic context beyond the schema (integer vs string/null), including default values and configuration dependency.

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

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

The description explicitly states '[READ] Recent backup run logs: status + failed-task messages.' This clearly identifies the verb (list/recent), resource (backup run logs), and scope (recent). It distinguishes from sibling tools like backup_job_list (which lists jobs) and backup_failure_rca (which analyzes failures) by focusing on raw run logs.

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 begins with '[READ]' signifying it is a safe query operation, distinguishing it from action tools (e.g., vm_start). However, it does not explicitly compare with other read siblings like backup_job_list or backup_failure_rca, nor does it provide when-not-to-use guidance. The context is implied but not explicit.

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

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

The description includes a [READ] prefix indicating non-destructive behavior, and gives a sense of returned fields. However, no annotations are provided, and the description does not detail potential errors, authorization needs, or other behavioral traits beyond the basic operation.

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

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

The description is extremely concise, using a single sentence for purpose and a clear 'Args' section for parameters. Every word serves a purpose.

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 (2 parameters, no nested objects, no output schema), the description covers the essential: purpose, parameter meanings, and return concept. It could mention return type or error cases, but is mostly 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?

With 0% schema description coverage, the description adds clear semantics: host_id is a UUID and refers to host_list, target is a config name with a default. This goes beyond the schema's type-only 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 it retrieves details for a single host by UUID, listing specific fields (version, build, memory, VMs). This distinguishes it from sibling tools like host_list (list all hosts) and vm_get (different resource).

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

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

The description implies usage when needing a single host's details, but does not explicitly state when to use vs. alternatives like host_list or when not to use. 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.

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

The description includes a '[READ]' prefix indicating it's a safe read operation, but does not disclose other behavioral traits such as pagination, rate limits, or what happens if no hosts match. Given no annotations, the description carries the burden and falls short of full transparency.

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

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

The description is extremely concise: a one-line summary followed by two bullet-point args with no filler. Every sentence serves a purpose.

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

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

While the description covers the primary purpose and parameters, it lacks details on the return structure (beyond mentioning fields), error scenarios, or behavior when filters are invalid. Given no output schema, more completeness would benefit an AI agent.

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

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

Schema description coverage is 0%, but the description adds clear semantics: 'Optional pool uuid to filter by' and 'target name from config; omit for the default'. This provides meaning beyond the schema property titles.

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

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

The description clearly states it lists hosts and specifies the returned fields: version, state, memory usage, resident VM count. This distinguishes it from sibling tools like host_get (single host) and vm_list (VMs).

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 optional parameters (pool, target) but does not explicitly tell when to use this tool versus alternatives like host_get. It omits any 'when not to use' or comparative 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?

Annotations are absent, so description carries full burden. Discloses best-effort execution and error block behavior, adding important behavioral context beyond the schema. Also indicates read-only nature with '[READ]'.

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?

Description is concise with a header and brief explanation. Every sentence adds value. Could be slightly more structured, but it's efficient and front-loaded.

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

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

Given the complexity of fanning out into multiple collections and no output schema, the description lacks detail on the return structure. It summarizes what is covered but doesn't specify the output format, which may reduce completeness for an agent.

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

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

Only one parameter 'target' with schema coverage 0%. Description explains it as 'Xen Orchestra target name from config; omit for the default', providing meaning and usage guidance beyond the schema minimal definition.

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

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

Description clearly states verb '[READ]' and resource 'health summary' covering specific entities (pools, hosts, VMs, SRs, recent backups). It distinguishes from sibling read ops by being a one-shot aggregator that fans out, providing a clear starting point for triage.

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 says 'Start any triage here' and explains it fans out over other read ops, indicating when to use. Mentions best-effort behavior and error handling. No explicit exclusions or alternatives listed, but context is clear enough.

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

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

No annotations provided; description adds '[READ]' to indicate non-destructive operation and mentions configuration dependency. Lacks details on error handling or side effects, but adequate for a simple read 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?

Extremely concise: 4 lines with clear header and bullet-point arguments. No wasted words, every sentence adds value.

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

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

Covers core functionality and parameter usage well. Lacks explicit return format but acceptable given no output schema. Slightly more detail on what 'detail' includes would improve completeness.

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

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

Schema description coverage is 0%, but description fully explains both parameters: pool_id reference to pool_list for valid UUIDs, target as optional config name with default. Adds essential meaning beyond schema.

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

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

Explicitly states 'Detail for one pool by uuid.' Clearly specifies verb (READ/detail), resource (pool), and identifier (uuid). Differentiates from pool_list (list all) and pool_patch_ha_posture (patch HA posture).

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

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

Provides clear guidance on parameters: pool_id should come from pool_list, target is optional with default. Does not explicitly exclude other tools but context is clear for this read operation.

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

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

The description includes '[READ]' to indicate read-only behavior and lists the returned fields (master, HA state, default SR). There are no annotations to contradict, and for a simple list tool, this is adequately transparent.

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

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

The description is extremely concise with no filler. The purpose is front-loaded, and the parameter explanation is neatly placed in an Args section. Every sentence serves a purpose.

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

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

For a simple list tool with one optional parameter and no output schema, the description is fairly complete. It specifies what fields are returned and explains the parameter. It could mention that it lists all pools (implied) or potential error conditions, but overall 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?

The schema has 0% description coverage, but the description fully explains the single parameter 'target': 'Xen Orchestra target name from config; omit for the default.' This adds significant meaning beyond the schema's type and default.

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

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

The description clearly states the verb 'List' and the resource 'XCP-ng pools', and specifies the attributes included (master, HA state, default SR). This distinguishes it from siblings like pool_get (specific pool) and pool_patch_ha_posture (modify HA).

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 pool_get or host_list. The description lacks explicit 'when to use', 'when not to use', or references to sibling tools.

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

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

No annotations provided, so description carries full burden. Declares read-only via [READ] tag and outputs cause+action per finding, but does not disclose if operation affects system state, permissions needed, or behavior when pool_id is omitted (likely analyzes all pools).

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?

Front-loaded with purpose and result format, followed by a bullet list of findings and a separate args section. Every sentence adds value; no redundancy.

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

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

No output schema, so description adequately covers return format as 'cause + action per finding' and lists what it checks. However, it does not specify if the result is a single object or an array, or how multiple pools are represented.

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

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

Schema coverage is 0%, so description compensates by explaining pool_id as 'Optional pool uuid to analyze just one pool' and target as 'Xen Orchestra target name from config; omit for the default.' This adds meaningful context beyond 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?

Clearly states it analyzes patch and HA posture per pool, enumerates specific findings (missing patches, pending reboot, version skew, multi-host HA absence), and distinguishes from sibling RCA tools like backup_failure_rca or vm_health_rca.

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?

Implied that it should be used to diagnose pool patch and HA issues, but lacks explicit when-to-use or when-not-to-use guidance compared to alternatives. No mention of prerequisites or limitations.

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

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

With no annotations provided, the description carries the full burden. It includes '[WRITE][risk=medium]' indicating write operation and risk level. It explains undo recording (real ID captured from XO response) and dry_run behavior (preview without snapshotting, no undo recorded). This provides meaningful behavioral context beyond the basic operation.

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

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

The description is concise at 6 sentences. It front-loads the core action and risk, then explains undo recording, then lists parameters. Every sentence adds value without redundancy.

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

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

For a snapshot creation tool, the description covers the main behavior, parameter semantics, and undo mechanism. However, it lacks details on return value (e.g., snapshot ID) and possible errors (e.g., VM not found). Given no output schema, this information would be helpful for completeness.

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

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

Schema description coverage is 0%, so the description must compensate. The Args section explains each parameter: vm_id (VM uuid, see vm_list), name (with example), dry_run (preview behavior), target (Xen Orchestra target, optional). This adds significant value over the schema, though could be more detailed on default behavior for target.

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

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

The description starts with '[WRITE][risk=medium] Snapshot a VM.' clearly indicating the action and scope. It also mentions the inverse operation (snapshot_delete), distinguishing it from sibling tools like snapshot_list and snapshot_revert.

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

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

The description provides guidance on using the tool (e.g., referencing vm_list for vm_id, naming convention) and mentions dry_run preview. However, it does not explicitly state when to use this tool versus alternatives like snapshot_list, snapshot_delete, or snapshot_revert, nor does it explain when not to use it.

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

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

Despite no annotations, the description labels the operation as [WRITE][risk=high], declares irreversibility, describes audit logging, and notes dry_run for safety.

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

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

Two sentences and a brief Args section; front-loaded with purpose and risk. No redundant information.

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

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

Covers purpose, risks, parameters, and audit behavior. Lacks explicit return value description, but for a delete operation this is adequate.

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

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

All three parameters (snapshot_id, dry_run, target) are explained beyond the schema, which has 0% coverage. Provides defaults and cross-reference to snapshot_list.

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 'Delete a VM snapshot by uuid' with a clear verb and resource, and includes risk labeling. It distinguishes from sibling tools like snapshot_list and snapshot_create.

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

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

Provides context for when to use (deletion) and mentions dry_run for preview, but does not explicitly state when not to use or compare to alternatives like snapshot_revert.

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

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

The description explicitly marks the tool as '[READ]', details the return format including truncation behavior, and explains that limit is applied after filtering. This adds transparency 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 concise and well-structured: a one-line summary, return format, then parameter details. Every sentence is informative with no fluff.

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

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

Given 3 parameters, no output schema, and no annotations, the description is complete. It covers the return value format, parameter semantics, truncation, and filtering behavior.

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, but the description thoroughly explains each parameter: vm_id (optional filter, cross-reference), limit (max after filtering, default), and target (default target). This adds essential meaning.

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 'List' and the resource 'VM snapshots', with optional filtering. It distinguishes from sibling tools like snapshot_create, snapshot_delete, and snapshot_revert by being a read-only list 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?

The description explains when to use each parameter (optional vm_id filter, limit, target). It references vm_list for vm_id context. However, it does not explicitly state when not to use the tool or mention alternatives among siblings.

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

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

No annotations provided, but the description fully covers behavioral traits: marks the operation as WRITE with high risk, explicitly states it is IRREVERSIBLE, explains state replacement, and mentions audit capture. No contradictions.

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?

Four sentences plus three parameter lines, no wasted words. Key information is front-loaded in the first line. Every sentence contributes value.

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

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

Covers purpose, parameters, and behavior well. However, no output schema is provided and the description does not mention return values or success indicators, which is a minor gap for contextual completeness.

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

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

Schema description coverage is 0%, but the description provides detailed comments for all three parameters: snapshot_id ('Snapshot uuid to revert to', referencing snapshot_list), dry_run preview behavior, and target default behavior, adding significant meaning beyond the schema.

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

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

The description clearly states 'Revert a VM to a snapshot' with a specific verb and resource, and includes a risk marker. This distinguishes it from sibling tools like snapshot_create and snapshot_delete.

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 advises to take a fresh snapshot first if one may need to come back, implying when to use snapshot_create as a preparatory step. Does not explicitly list alternatives, but provides clear context for when to use this tool.

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

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

No annotations are provided, so the description must fully convey behavioral traits. It indicates a read operation with '[READ]' but fails to disclose what 'detail' includes, whether any side effects exist, authentication requirements, or error conditions. This is insufficient for a tool with no structured behavioral metadata.

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

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

The description is extremely concise—two short lines for the purpose and a bullet list for arguments. No redundant words, and the '[READ]' prefix immediately communicates the operation type. 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 the absence of an output schema, the description should hint at the return value. It does not explain what fields constitute the 'detail.' For a simple get tool, the description is minimally adequate but lacks completeness compared to siblings that might have richer descriptions.

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

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

Schema coverage is 0%, but the description adds meaningful context for both parameters: sr_id is explained as 'SR uuid (see sr_list)' and target as 'Xen Orchestra target name from config; omit for the default.' This helps beyond the raw schema but does not provide exhaustive details like format constraints.

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

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

The description starts with '[READ]' and explicitly says 'Detail for one SR by uuid.' This clearly communicates the verb (read/get), the resource (SR), and the identifier (uuid). It distinguishes from sibling tools like sr_list (list) and sr_rescan (rescan).

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 hints at usage by referencing sr_list to obtain the uuid and notes that the target can be omitted for default. However, it does not explicitly state when to use this tool versus alternatives (e.g., sr_rescan, sr_usage_rca) or provide any when-not-to-use guidance.

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

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

No annotations provided, so description carries full burden. Clearly marks as read operation '[READ]', describes return format including truncation flag for pagination. No mention of authentication needs or performance, but sufficient for a read 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?

Concise: one-line summary, return format, then args section. No wasted sentences, front-loaded with purpose.

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?

No output schema, but description details return format including 'returned', 'limit', 'truncated' fields. Covers all parameters. Complete for a simple list tool.

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

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

Schema description coverage is 0%, but description explains all three parameters: pool (optional UUID filter), limit (max results, default 200), target (optional config name). Each parameter's purpose and default are clear.

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?

Starts with '[READ] List SRs with capacity, physical usage, virtual allocation.' Clearly states verb (list) and resource (SRs), and specifies included fields. Distinguishes from sibling tools like vm_list or sr_get.

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?

Does not explicitly state when to use vs. alternatives. Implied usage via parameter descriptions (optional pool filter, limit), but no when-not or alternative tool guidance.

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

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

With no annotations, the description fully discloses that this is a write operation with no data change, no undo, and a dry_run capability. It acknowledges the risk level ('medium') and explains that refresh records no undo because there's no prior state. This is comprehensive for a simple mutation tool.

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

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

The description is highly efficient: a one-line header with risk and nature, followed by a brief paragraph explaining the write impact, then a compact Args list. Every sentence provides essential information without redundancy.

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

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

Given 3 parameters, no annotations, and no output schema, the description covers purpose, usage, and parameters well. It lacks information about the return value or side effects after a rescan, but this is minor for a metadata refresh tool.

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

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

Schema description coverage is 0%, but the description provides detailed explanations for all three parameters: sr_id (a UUID from sr_list), dry_run (preview mode), and target (optional Xen Orchestra target). This adds significant meaning beyond the 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 action (rescan) and resource (SR), with a specific verb and context ('metadata refresh — no data change, no undo'). It distinguishes from sibling tools like sr_list, sr_get, sr_usage_rca by implying it's a write operation for refreshing metadata.

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 when to use this tool (metadata refresh after storage changes) and includes a dry_run option for preview. It notes that it's the lowest-impact write and warns of no undo, but does not explicitly mention alternatives or when not to use it.

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

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

Clearly labels as [READ] and details analysis steps (ranking, flagging, totaling), providing transparency beyond default expectations without annotations.

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

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

Two terse paragraphs; first conveys purpose and key actions, second documents parameter. No fluff, 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?

Covers purpose, actions, and parameter adequately. Lacks explicit output format but given simple input, it is sufficiently complete for selection and invocation.

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

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

Explains the 'target' parameter meaning (Xen Orchestra target name, optional) despite 0% schema coverage, adding value over the schema's anyOf definition.

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

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

Description states 'SR usage root-cause analysis' with specific actions (rank, flag, total), distinguishing it from sibling RCA tools like backup_failure_rca and vm_health_rca.

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?

Implies usage for analyzing SR storage issues but lacks explicit when-to-use vs alternatives or when-not-to-use guidance.

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

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

The description starts with '[READ]' indicating it's a read-only operation, and explains the return format including the truncated field. No annotations exist, so the description carries the burden and does well, though it omits details like error handling.

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

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

The description is concise and well-structured: first line states purpose, second line shows return format, third line explains truncated, then Args section. No wasted words.

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

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

Given the lack of annotations and output schema, the description covers the return format, parameter meanings, and usage of the truncated field. It could be more complete with error scenarios or prerequisites, but it is sufficient for basic use.

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

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

All three parameters (status, limit, target) are explained in the description with specific allowed values for status and default values for limit and target. This adds significant value beyond the schema which has no descriptions.

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

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

The description clearly states it lists XO tasks with optional filtering by status. The verb 'list' and resource 'XO tasks' are specific and distinct from sibling tools that list other resources like VMs or 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?

Guidance on optional filtering by status and handling truncated results is provided. However, there is no explicit when-to-use or when-not-to-use compared to other tools, though the tool name makes its purpose clear.

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

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

No annotations provided, so description carries full burden. Discloses write operation, medium risk, inverse audited under its own tier, dry_run behavior, and token single-use. Adds value beyond structured fields.

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?

Efficiently structured with summary, behavioral prose, and parameter list. No redundant sentences, every part adds value.

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

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

Covers key aspects but omits return value description and error handling. Given no output schema, a brief note on what the result contains would improve completeness.

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

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

Schema coverage is 0%, but description's Args section fully explains each parameter's purpose and source (e.g., undo_id from undo_list or _undo_id). Adds meaning beyond 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?

Clearly states 'Apply a recorded undo by dispatching its inverse tool,' specifying verb and resource. Distinguishes from sibling 'undo_list' by focusing on application rather than listing.

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

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

Explicitly describes when to use: to apply a recorded undo. Mentions dry_run for preview and token single-use constraint. Lacks explicit when-not-to-use or alternatives but is clear enough for an agent.

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 for safety and behavior. It explicitly declares '[READ]' to indicate non-destructive operation, and discloses important nuances: the extra row for accurate 'truncated' detection, the meaning of 'effectVerified' including the warning that false means the change is probable not confirmed, and the instruction to check live state before applying. This is comprehensive and actionable.

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

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

The description is well-organized: a concise summary sentence, followed by necessary details about fields, usage, and the warning about effectVerified. Each sentence adds value, and the Args section cleanly documents parameters. Despite length, nothing is verbose or redundant.

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

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

Given the tool has no output schema and no annotations, the description fully covers return behavior (entry fields, ordering), pagination semantics (truncated via extra row), parameter behavior, and a subtle data-quality caveat. It leaves no significant questions for an agent and is complete for safe invocation.

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

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

The input schema provides only types and defaults with zero description coverage. The description fully compensates: it explains 'limit' (max rows, default 50, capped at 500) and 'target' (unused, accepted for CLI uniformity), adding meaning beyond the schema's bare structure.

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

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

The description starts with '[READ] List recorded, not-yet-applied undo tokens (most recent first)', which is a specific verb+resource+scope. It clearly distinguishes this from sibling tools like undo_apply, which applies the tokens, and other list tools for different resources.

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

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

The description gives explicit usage context: 'Use the undoId with undo_apply.' It also explains the limit parameter and the purpose of the extra row for measuring truncation. However, it doesn't explicitly contrast with sibling list tools, though the resource type (undo tokens) makes alternatives clear.

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

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

Without annotations, the description fully discloses behavior: it's a read operation, returns a structured object with truncation info, and defines key terms. No contradictions.

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, efficient, and front-loaded with the read hint and purpose. Every sentence adds value without unnecessary words.

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

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

Given no output schema, the description includes the return format. All 4 parameters are documented. The tool is simple and the description covers its essential behavior completely.

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 add meaning. It explains each parameter (sr, orphaned_only, limit, target) with clear semantics, including default values and purpose.

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

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

The description starts with '[READ]' and clearly states 'List VDIs (virtual disks), optionally per SR or orphaned-only.' This specific verb and resource set it apart from sibling tools like vm_list or sr_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 when to use filters (sr, orphaned_only) and defines orphaned for context, but does not explicitly say when not to use the tool or mention alternatives.

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

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

No annotations are provided, so the description carries full burden. It marks the operation as [READ] and lists returned fields, which is sufficient for a simple get tool. It does not mention side effects, authentication, or rate limits, but for a read-only tool this is acceptable.

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

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

The description is extremely concise with no wasted words. It front-loads the purpose with '[READ]' and uses a clean args list format. Every sentence is necessary.

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

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

Given no output schema, the description mentions fields returned but is incomplete. It does not describe the full return structure (e.g., object shape, nested fields). More detail about the response would improve completeness for a detail-fetching tool.

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

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

Schema coverage is 0%, but the description adds meaningful explanations: vm_id as VM uuid with a reference to vm_list, and target as the Xen Orchestra target name with default behavior. This adds value beyond the schema property titles.

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

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

The description clearly states a read operation for one VM by uuid, listing specific fields (state, host, OS, tools, tags). It distinguishes from vm_list which lists VMs and vm_stats for statistics.

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 an args list explaining vm_id and target, and references vm_list for obtaining the uuid. However, it does not explicitly state when to use this tool versus alternatives like vm_list or vm_stats, though context from sibling names implies it.

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

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

No annotations given, so the description carries the burden. It explicitly labels as [READ] indicating read-only operation, and lists the types of findings, providing a good overview of expected behavior without side effects.

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

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

Well-structured with a header, bullet list of checks, and argument descriptions. Slightly verbose in the bullet list but overall efficient and clear.

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 2 parameters, no output schema, and no annotations, the description covers purpose, parameters, and the nature of output (cause+action per finding). Sufficient for a simple tool.

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

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

Schema coverage is 0%, but the description fully explains both parameters: vm_id (optional, for single VM analysis) and target (optional, default). Adds significant meaning beyond the schema.

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

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

The description clearly states it performs root-cause analysis on VM health, listing specific flags (halted, paused, missing guest tools, CPU/memory pressure). This distinguishes it from sibling tools like backup_failure_rca or sr_usage_rca.

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

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

Provides clear context: analyze one VM with vm_id or the whole fleet. Implicitly guides when to use this tool for VM health issues, but does not explicitly exclude other tools or scenarios.

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

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

The description discloses the return format and the critical truncation behavior ('When truncated is true there are more VMs than were returned — re-run with a higher limit'). Annotations are absent, so the description carries full burden. It does not mention side effects, authentication, or rate limits, but for a read-only list tool this is sufficient. The [READ] prefix adds clarity.

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

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

The description is very concise: one sentence for purpose, one for return format, one for truncation behavior, and a clean parameter list. Every sentence adds value. It is front-loaded with the purpose and structured logically.

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

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

Given the tool has 4 parameters, no output schema, and moderate complexity (filtering, truncation), the description covers everything needed: purpose, return shape, critical truncation behavior, and all parameters. There is no missing information that would hinder correct usage.

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

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

The description documents all four parameters (power_state, pool, limit, target) with their purpose and defaults. The input schema has no property descriptions (0% coverage), so the description fully compensates by providing meanings and expected values. It also explains the truncation behavior in context of limit.

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

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

The description starts with '[READ] List VMs with power state, host, tools status, sizing.' This clearly states the verb (List) and resource (VMs), and it specifies the fields returned. It also distinguishes from sibling tool 'vm_get' which retrieves a single VM.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or when not to use it. The only contextual hint is the '[READ]' prefix, but no explicit comparison with sibling tools like 'overview' or 'backup_job_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?

The description fully discloses behavioral details: it is a write operation with medium risk, records the source host for undo, and dry_run prevents recording. It adds context beyond annotations (which are absent), covering the undo mechanism and preview behavior.

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

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

The description is concise, starting with an action line, then a behavioral note, followed by parameter definitions. Every sentence adds value, and the structure is easy to parse.

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

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

The description covers behavior and parameters well, but lacks details on return value (no output schema) and prerequisites like VM state or permissions. Given the tool's complexity and absence of output schema, it is nearly 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?

With 0% schema coverage, the description compensates entirely by explaining each parameter: vm_id (UUID from vm_list), host_id (UUID from host_list), dry_run (preview, no undo), and target (optional, defaults). This adds critical meaning beyond the schema's type-only 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 action ('Live-migrate a VM to another host'), resource (VM), and scope. It distinguishes from sibling tools like vm_start, vm_stop by specifying live migration across hosts and mentioning the inverse 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?

The description provides context for use (live migration, undo via inverse) and explains the dry_run parameter for preview. However, it does not explicitly state when this tool should be used over alternatives (e.g., vm_reboot, snapshot_revert) or when not to use it.

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

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

With no annotations, the description carries full burden. It declares '[WRITE][risk=medium]', mentions 'No undo', and explains the behavior of force and dry_run parameters. This provides good transparency 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 concise with a clear header and structured Args section. It is front-loaded with the core action and risk, but some redundancy (e.g., 'No undo' repeated) slightly reduces efficiency.

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

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

Given 4 parameters, no output schema, and no annotations, the description covers the tool's purpose, all parameters, and key behavioral aspects (no undo, audit). It lacks explicit return value info but is otherwise 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 coverage is 0%, and the description fully explains each parameter: vm_id (source from vm_list), force (hard vs clean), dry_run (preview), target (default from config). This adds significant meaning beyond the bare schema.

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

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

The description clearly states 'Reboot a VM (clean; hard with force)', which is a specific verb+resource. It distinguishes from siblings like vm_start and vm_stop by focusing on reboot, not start or stop.

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 context (no undo, audit record) but does not explicitly state when to use this tool vs alternatives like vm_start/vm_stop. Usage is implied but lacks explicit 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 full burden. It notes a risk level of 'medium' and explains that dry_run mode records no undo, but does not mention other behavioral aspects such as permissions, side effects for already-running VMs, or error handling.

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

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

The description is very concise, with a clear front-loaded purpose statement followed by a structured 'Args' section. Every sentence adds value without redundancy.

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

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

For a simple tool with 3 parameters and no output schema, the description covers the essential usage and parameter semantics. However, it lacks details on return values or potential failure modes, which could be useful.

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

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

Schema description coverage is 0%, but the description adds full semantic meaning for all three parameters: vm_id (UUID from vm_list), dry_run (preview without undo), and target (Xen Orchestra target with default). This greatly enhances 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 'Start a VM' with the verb 'Start' and resource 'VM'. It also explicitly mentions the inverse tool 'vm_stop', distinguishing it from its sibling.

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 via the 'Args' section, explaining the purpose of each parameter. It mentions the inverse tool as an alternative, but does not explicitly state when not to use this tool or provide broader usage 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 description includes a '[READ]' prefix, indicating it is read-only and safe, and mentions 'RRD-backed averages'. However, it lacks details on authorization requirements, error handling, or performance implications. Without annotations, the description partially fulfills transparency but has gaps.

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, well-structured, and front-loaded with the purpose. Every sentence adds value without redundancy, making it easy to parse quickly.

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

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

For a simple stats tool with no output schema, the description adequately covers inputs, behavior (read-only, RRD-backed), and parameter defaults. It does not explain return format or error cases, but given the tool's simplicity and low complexity, it is nearly 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 description explains all three parameters in detail: vm_id as 'VM uuid', granularity with allowed values and default, and target with context. Since the schema has no descriptions and 0% coverage, the description fully compensates and adds essential meaning.

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

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

The description clearly states it returns 'Recent CPU / memory stats for a VM' and labels it as a read operation. The purpose is specific and distinct from sibling tools like vm_get or vm_health_rca, though it does not explicitly differentiate them.

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 or vm_health_rca. The description implies it's for historical averages but does not offer explicit when-not-to-use or prerequisite information.

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

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

Discloses key behaviors: captures prior power state, refuses to stop XO self VM, dry_run gives preview but refuses that specific call, and explains selfVmHint as a coincidence check. Without annotations, this carries the full burden and does so thoroughly.

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

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

The description is somewhat verbose but well-structured with a summary line, detailed explanations, and a clear args section. Every sentence adds value, though it could be slightly condensed without losing clarity.

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

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

Covers all aspects: mutation behavior, edge cases (self VM block, dry_run), parameter details, dependencies (guest tools), and recovery implications. No output schema exists, but the description provides sufficient context for correct invocation.

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

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

Adds meaning beyond schema for all 4 parameters: vm_id references vm_list, force describes hard power-off, dry_run explains preview behavior and interaction with self-VM guard, target specifies Xen Orchestra target. Schema coverage is 0%, so description fully compensates.

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

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

The description explicitly states it stops a VM, distinguishes between clean shutdown and hard power-off, and captures prior power state. It differentiates from sibling tools like vm_start, vm_reboot, and vm_migrate by focusing on stopping a VM.

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

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

Provides clear when-to-use guidance: inverse of vm_start, force for hard power-off, clean shutdown needs guest tools. Also specifies when not to use: refuses the XO self VM and dry_run refusal. Includes context for target parameter and default handling.

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