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

The annotations indicate destructiveHint=true, and the description reinforces this with a warning emoji and 'Opération potentiellement destructive!'. This goes beyond the annotation by emphasizing potential destructive behavior in human-friendly terms. Also, the description conveys that it applies retention policies, implying it may delete backups based on those policies. While it doesn't detail irreversibility, the warning adds value beyond the annotation, so a 4 is appropriate.

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

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

The description is a single sentence that states the core action and includes a clear warning. It is concise and front-loads the purpose. The warning is placed advantageously. It earns a 4 because it is efficient without sacrificing clarity, though it could be slightly more structured (e.g., separating the warning).

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 destructive nature and the lack of an output schema, the description should provide more context: what exactly gets deleted, whether dry_run is available (it is a parameter), and any safeguards. The schema does have dry_run and force, but the description doesn't mention them. The description is adequate but not complete for an agent to use confidently. It covers the primary purpose but misses important behavioral nuances like the existence of a dry-run mode. A 3 is justified.

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, meaning no parameter descriptions are provided. Thus, the description must compensate. The description does not explain any parameter semantics; it only explains the tool's overall purpose. However, the parameter names are fairly self-explanatory (type, force, dry_run, keep_last), and the enum for type provides some context. Given the low coverage, the description should have compensated more, but the parameter self-explanatoriness and the enum help. Baseline for 0% coverage is low, and while the description doesn't add parameter-specific info, the tool's behavior is understandable. A 3 is fair.

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 that the tool applies retention policies and deletes old backups, which is a specific action on a specific resource. It clearly distinguishes from sibling backup tools (create, list, restore, verify, status) by focusing on deletion/retention. It is not a tautology and provides a clear purpose.

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

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

The description implicitly tells when to use it: when you need to clean up old backups according to retention policies. It does not explicitly state when not to use it or mention alternatives like backup_verify for checking integrity, or backup_restore for retrieval. The context signals suggest backups are managed by multiple tools, but no explicit routing is provided. A score of 3 reflects the implicit usage context but lack of exclusions.

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

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

The description only states that a backup is created and names possible types; it does not disclose side effects, required privileges, storage destinations, notification behavior, or output. Annotations already convey that the operation is not read-only and not idempotent, but the description adds little behavioral context beyond that.

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

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

The description is a single direct sentence with no filler or repetition. It front-loads the main action and then lists the backup types succinctly. It is concise, though slightly under-specified for such a complex tool.

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

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

With 10 parameters, no output schema, and zero parameter documentation, the one-line description is far from sufficient. An agent cannot determine which parameters are needed for each backup type, what the result will look like, or what side effects to expect. The description is minimally viable at best but inadequate for reliable 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?

Schema description coverage is 0%, so the description carries the full burden of explaining the 10 parameters, but it only echoes the possible values of the type parameter. It does not clarify the meaning or role of vm, dest, source, live, notify, verify, comment, dry_run, or timeout_ms. This is a substantial gap for an agent trying to construct a valid call.

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 and resource: 'Crée un backup' and enumerates the four supported backup types, which matches the type enum. It is unambiguous about the tool's core function and is distinguishable from the other backup_* siblings by its create action. However, it does not explicitly differentiate from the sibling vm_snapshot, which overlaps with the 'vm-snapshot' backup type.

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 no guidance on when to use backup_create versus alternatives like vm_snapshot, backup_restore, or backup_list. It lists possible types but does not explain the conditions under which one type should be chosen over another. No when-to-use or when-not-to-use information is provided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe, non-mutating behavior is covered. The description adds only the scoping idea of 'by type or all', which is a modest behavioral insight but does not disclose details like output format, pagination, or how the sort/limit parameters affect results.

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

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

The description is a single, compact sentence with no filler. It front-loads the core action and the main optional scoping distinction, earning its place 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?

With five optional parameters, no output schema, zero parameter descriptions, and several backup-related sibling tools, this description is too thin. An agent cannot infer what 'detailed', 'sort', or 'limit' mean, nor how backup_list differs from backup_status, leaving important context missing.

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

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

Schema description coverage is 0%, so the description must compensate for explaining parameters. It only hints at 'type' and 'all' with 'par type ou tous', but leaves sort, limit, and detailed entirely unexplained. This is insufficient for a tool with five optional parameters.

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

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

The description states a clear verb and resource: 'Liste tous les backups disponibles' (list all available backups), with an explicit filtering hint 'par type ou tous' (by type or all). It clearly names the tool's purpose, though it does not differentiate it from the sibling backup_status, which could also be about listing or showing backups.

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 no guidance on when to use this tool versus alternatives such as backup_status, backup_verify, or backup_clean. It does not mention prerequisites, typical use cases, or exclusions, leaving the agent to infer when 'list backups' is the appropriate call.

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 repeats the destructive nature already declared by destructiveHint=true, but adds no extra behavioral context such as what gets overwritten, whether confirmation is required, or what safeguards like dry_run or force do. There is no contradiction with annotations, so the annotation carries most of the burden.

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

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

The text is short and front-loaded with the core action, but the destructive warning is repeated twice ('ATTENTION: opération destructive!' and 'ATTENTION: Opération potentiellement destructive!'), making part of the description 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?

For a destructive tool with seven parameters, no output schema, and zero parameter descriptions, a one-sentence warning is insufficient. The description does not explain how restoration works, what the parameters control, or what the expected outcome is, leaving major gaps for the agent.

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

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

Schema description coverage is 0%, and the description mentions none of the seven parameters: type, identifier, force, target, dry_run, partial, or skip_pre_snapshot. An agent gets no help understanding what to pass or why, especially since the schema itself has no parameter 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 states 'Restaure un backup' (restore a backup), which clearly identifies the action and resource. It is distinguishable from siblings like backup_create, backup_list, backup_verify, and backup_clean by the verb 'restore', though it does not explicitly contrast itself with 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?

There is no guidance on when to use this tool versus alternatives such as backup_verify or backup_list, nor any mention of prerequisites like locating a backup identifier first. The destructive warning is a caution, not a usage guideline.

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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the dashboard scope (status, espace, alertes), but does not disclose the behavior of the 'watch' parameter or what the output looks like. No contradiction with the 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?

The description is a single focused sentence that front-loads the verb, resource, and key content areas. There is no wasted text or irrelevant detail.

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

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

For a simple read-only status tool, the description gives a minimally viable idea of what the tool returns. However, with no output schema and no explanation of the two parameters, an agent cannot fully anticipate the response format or how to customize the view. The missing parameter semantics is the main gap.

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 for the undocumented 'watch' and 'compact' parameters. It does not mention either parameter or explain how they affect the dashboard. The names are mildly self-explanatory, but the description adds no semantic value.

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 uses a clear verb and resource: 'Affiche le dashboard global des backups' with the scope 'status, espace, alertes'. It conveys an overview dashboard, which implies a distinction from sibling list/verify tools, but it does not explicitly differentiate itself from backup_list or backup_verify.

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

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

No explicit guidance on when to use this tool versus alternatives such as backup_list or backup_verify. The word 'global' weakly implies a high-level overview, but there are no conditions, exclusions, or sibling references to guide 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. However, the description adds no additional behavioral context such as performance implications of deep/quick modes, what exactly is verified, or how results are returned. It merely restates the tool's purpose without enriching the agent's understanding.

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

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

The description is a single short sentence with no fluff, which is concise. However, it is under-specified to the point of being unhelpful for a tool with five parameters. It is not 'appropriately sized' because it omits essential information, earning a mid-range score.

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

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

With five parameters, zero schema descriptions, and no output schema, the description must provide substantial context. It gives none, leaving the agent to guess what each parameter does, what checks are performed, and what the return value looks like. This is severely incomplete for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must fully compensate for parameter meaning. It mentions nothing about 'deep', 'quick', 'type', 'backup_id', or 'timeout_ms', leaving all five parameters unexplained. The agent cannot know how to set them correctly.

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

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

The description clearly states the action (verifies) and the resource (backups) with a specific focus on integrity. It distinguishes from sibling tools like backup_list or backup_status by specifying 'integrity', but it does not explicitly name alternatives or contrast itself, so it earns a 4 rather than a 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?

There is no guidance on when to use this tool versus alternatives like backup_status, backup_list, or backup_clean. The description gives no context, prerequisites, or exclusions, leaving the agent to infer usage solely from the name.

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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the advice to call it first, which is a behavioral suggestion but doesn't disclose additional traits like return format or side effects. It adds marginal value beyond the annotations but doesn't contradict them.

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

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

The description is two concise sentences with no waste. The purpose is front-loaded in the first sentence, and the usage instruction in the second. It's efficient and directly to the point.

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 help tool with no parameters and no output schema, the description fully covers what it does and when to use it. The return (a list of tools with descriptions) is self-explanatory given the name and description. Nothing essential is missing.

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

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

The tool has zero parameters, and the schema coverage is 100% (vacuous). The baseline for 0 params is 4, and the description doesn't need to explain parameters since none exist. It correctly omits any parameter details.

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

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

The description clearly states a specific verb ('Liste' - lists) and resource ('tous les outils disponibles avec leurs descriptions' - all available tools with their descriptions). It also instructs to call this tool first, which clarifies its purpose as an entry point. This distinguishes it from the sibling tools which are all specific operations.

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 'Appelle cet outil en premier' (call this tool first), providing a clear usage directive. It doesn't mention alternatives or when not to use it, but as a help tool it's self-evidently the initial discovery step. The guidance is sufficient for an agent to know when to invoke it.

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

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

The description adds only 'complet ou lié' as behavioral context and does not disclose side effects, long-running operation risk, storage implications, or source VM modification. Annotations provide only basic boolean hints and do not compensate for the missing 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 a single, front-loaded sentence with no filler. It is efficient, though arguably too terse to be a complete tool definition.

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?

This is an 8-parameter mutation tool with no output schema and no parameter descriptions. The one-line description omits essential context such as what full vs linked cloning entails, prerequisites, return behavior, and how it relates to vm_clone_system. It is far below the minimum viable level of 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?

With 0% schema description coverage, the description must compensate by explaining parameters, but it only hints at linked mode and an existing source VM. Parameters like start, network, autostart, timeout_ms, and tracking_session_id receive no explanation beyond their names.

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

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

The description uses a specific verb ('Clone') with a specific resource ('une VM KVM existante') and names the two modes ('complet ou lié'). It clearly communicates the core function, though it does not explicitly distinguish itself from sibling tools such as vm_clone_system or vm_copy.

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 about when to use this tool versus alternatives like vm_clone_system, vm_copy, or vm_import. There is also no mention of prerequisites, such as whether the source VM must be stopped, or trade-offs between full and linked clones. The agent must infer usage entirely from the action.

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

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

The description includes a warning that the operation is potentially destructive, which aligns with the destructiveHint=true annotation. It does not add much beyond the annotation, such as what specifically may be destroyed, whether downtime is involved, or whether dry_run prevents all side effects.

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

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

The description is a single front-loaded sentence with an explicit warning. It is concise and every word contributes to understanding the core purpose and risk.

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

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

With 8 parameters, no output schema, and no parameter semantics, the description is far from sufficient for an agent to invoke the tool correctly. It lacks prerequisites, operational effects, return behavior, and any explanation of the dry_run safety mechanism.

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 provides no explanation of any of the 8 parameters. The agent gets no guidance on cpus, memory, disk_size, dry_run, hostname, username, timeout_ms, or name beyond the raw schema 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 states a specific verb and resource: clone the entire host system into a bootable KVM VM. This clearly distinguishes it from sibling tools like vm_clone, which presumably clone an existing VM, and from backup/export operations.

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 intended use is implied by the text: use this when you want a full host-system clone to a KVM VM. However, there is no explicit guidance about when not to use it or which alternative to prefer, such as vm_clone or vm_export.

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 already declare destructiveHint=true and readOnlyHint=false, so the warning is redundant. The description adds the SCP transport detail, which is useful but does not elaborate on what the destructive potential entails (e.g., overwriting files, affecting VM state). No contradiction with annotations exists.

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

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

The description is a single efficient sentence that front-loads the action and appends a prominent warning. It is appropriately sized for the minimal content it delivers, though it omits important parameter details that could be structured without becoming verbose.

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 7 parameters, including direction, recursive, checksum, and preserve, and no output schema, the description is far too sparse. It does not explain how to set parameters, what 'potentially destructive' means, or any prerequisites like SSH access or VM state. An agent would be unable to call this tool correctly without substantial inference.

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 mentions none of the 7 parameters. It fails to explain direction, recursive, checksum, preserve, or how source/dest relate to the VM. The agent gets no semantic meaning beyond raw parameter names, so the description does not compensate for the schema gap.

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

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

The description clearly states a specific action ('copy') and resource ('files between the host and a VM via SCP'), which distinguishes it from sibling tools like vm_exec (commands), vm_snapshot, and backup tools. The verb and resource are precise, and the warning does not obscure the core purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention conditions such as the VM needing to be running, nor does it name any alternative tools like vm_exec or backup tools. The destructive warning is not usage guidance, leaving the agent without decision-making support.

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 already mark destructiveHint=true and readOnlyHint=false, so the bar is lower. The description adds useful context beyond annotations by naming exactly what is destroyed ('définition + stockage') and flagging the operation as potentially destructive. It does not explain force/keep_storage side effects, but the annotation coverage carries part of the burden.

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

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

A single sentence with the main action front-loaded and the warning appended compactly. There is no filler or redundant explanation.

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 destructive tool with no output schema and three undocumented parameters, the description is too thin for fully confident invocation. An agent still cannot tell what `force` does, how `keep_storage` interacts with the stated default, or what to expect after execution. Annotations cover the destructive profile but not the operational details.

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

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

Schema description coverage is 0%, and the description does not mention `force` or `keep_storage` by name. The phrase '(définition + stockage)' only weakly hints that storage deletion is the default and that `keep_storage` may alter it, which is insufficient compensation for three undocumented parameters.

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

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

The description opens with a specific verb ('Supprime') and resource ('VM KVM') and explicitly states the destructive scope: definition plus storage. This makes it unambiguous against siblings like vm_stop or vm_snapshot.

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 destructive warning implies this tool is only for full removal rather than stopping or copying, but there is no explicit when/when-not guidance and no mention of alternatives or prerequisites like backups. Usage context is mostly inferred from the verb.

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 already declare destructiveHint=true, and the description repeats that warning, which is redundant. However, it adds the SSH connection mechanism, which is useful context beyond annotations. No contradictions exist. The description does not disclose other behaviors like privilege escalation or output capture, which are in the schema but not elaborated.

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

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

The description is a single, front-loaded sentence with a clear warning. It is appropriately concise and avoids redundancy. The warning is placed prominently. However, given the destructive nature, more explanatory content might be warranted, but the description is structurally sound.

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

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

The tool has six parameters, no output schema, and is destructive. The description lacks parameter explanations, usage guidance, and behavioral details beyond SSH. It does not explain return values, error handling, or the impact of destructive operations. An agent would struggle to invoke it correctly without additional knowledge.

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 carries the full burden of explaining parameter meaning. It does not mention any of the six parameters (vm_name, command, sudo, user, capture, timeout) or their roles. The schema itself provides only names and types, no descriptions. An agent cannot infer what 'sudo' or 'capture' do from the description.

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

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

The description clearly states the verb ('Exécute') and resource ('une commande dans une VM') and method ('via SSH'). It distinguishes from sibling tools like vm_start, vm_stop, vm_destroy by focusing on arbitrary command execution. The warning about destructiveness adds a clear safety signal.

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 no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or exclusions. An agent must infer from the name that this is for running commands, but there is no explicit routing or comparison to 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?

Annotations provide no positive hints (all false), so the description carries the full transparency burden. It openly discloses destructive sanitization operations in classic mode, the preserving behavior in exam mode, pre/post export tests, firstboot script installation, and the exact generated archive naming/location. There is no contradiction with the 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?

The description is dense but information-rich, front-loading the main purpose and then detailing modes, tests, and output naming in sequence. It remains reasonably concise for the complexity, though a bulleted structure for the three modes and tests would improve scannability.

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

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

For a 7-parameter tool with no output schema and no helpful annotations, the description covers the essential context: modes, sanitization, firstboot, tests, and output path. The main gaps are the undocumented force and dry_run parameters and the lack of any return/result information.

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 property descriptions have 0% coverage, so the description adds significant meaning: it explains mode values, operations[] in custom mode, firstboot behavior, and the default output location. However, it does not explain the semantics of force or dry_run, leaving two parameters ambiguous.

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 action ('Exporte une VM KVM'), the artifact format (archive portable .tar.gz), and the distinguishing purpose (sanitization of sensitive data). It is clearly distinguishable from siblings like vm_snapshot, vm_copy, and backup_create, which do not produce portable sanitized VM export archives.

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 each mode is appropriate: classic removes users and secrets, exam preserves accounts, custom allows selecting virt-sysprep operations, and firstboot installs the config script. This provides clear contextual usage guidance, though it does not explicitly contrast the tool with sibling backup/export tools or state 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?

The description goes beyond the destructiveHint annotation by warning 'Opération potentiellement destructive', and adds meaningful behavioral details: pre-import integrity tests, post-import verification, new UUID/MAC generation, default disk copy location, and SSH wait when start is set. It doesn't detail the exact destructive consequences, but the warning plus checks supply solid 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 dense but every sentence adds value: import source, validation steps, generated identity, default disk destination, start behavior, and a warning. It is front-loaded with the main purpose and contains 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 potentially destructive tool with no output schema, the description gives a strong overview: input, validation, side effects, and options. However, it lacks any indication of return values or success/failure reporting, and it leaves dry_run behavior unexplained, which is a minor but real completeness gap.

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 for five parameters. It indirectly covers archive_path, start, and the default pool_dir, but it does not explain dry_run or new_name, nor how name validation or pool override behaves. This is a meaningful gap.

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 uses a specific verb ('Importe'), a specific resource ('une VM KVM'), and the exact input source ('une archive exportee par vm_export'). This clearly distinguishes it from sibling tools like vm_export, vm_clone, and vm_copy without requiring schema inspection.

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

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

It states that the tool is for importing from an archive produced by vm_export and adds useful behavioral conditions such as 'Avec --start' and pre/post-import tests. It does not explicitly say when not to use it or contrast it with alternatives like vm_clone, but the context is clear enough for an agent to route 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?

The description includes a warning about potential destructiveness, which matches the destructiveHint=true annotation, so there is no contradiction. However, it adds little beyond the annotation: it does not explain what specifically gets destroyed (e.g., restoring overwrites current state, delete-all removes all snapshots) or clarify that create/list are non-destructive. The annotation already covers the destructive profile, so the added warning is redundant rather than additive.

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

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

The description is a single concise sentence with the warning front-loaded, making it extremely brief and easy to scan. However, it omits the 'delete-all' action, which is both a completeness and accuracy issue, and the warning merely duplicates the annotation, so a slight deduction is warranted.

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?

This is a multi-action tool with 6 parameters, no output schema, and 0% schema description coverage. The description only lists a few actions and a generic warning; it does not cover the action enum fully, does not explain the 'yes' and 'live' flags, and gives no sense of what the tool returns. An agent would need to infer or experiment to call it correctly across all supported operations.

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 carries the burden of explaining parameters. It only mentions a subset of the action enum and provides no explanation for critical parameters like 'yes' (confirmation), 'live' (live snapshot), 'snapshot_name', 'description', or 'vm_name'. Even though some names are self-explanatory, the description does not compensate for the complete lack of schema documentation, especially for the boolean flags.

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 names a clear resource ('snapshots d'une VM') and lists the main actions (create, list, restore, delete), which distinguishes it from VM-level tools like vm_start, vm_destroy, and backup-specific tools like backup_create. However, 'Gère' is a somewhat generic verb and the list omits the 'delete-all' action present in the schema's enum, so the scope is clear but not fully precise.

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 this tool is for managing VM snapshots, which provides basic context for when to use it. It gives no explicit guidance about when not to use it or which sibling tools (e.g., backup_create, vm_clone) might be appropriate alternatives, leaving usage selection mostly to inference.

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 already convey idempotency and non-destructiveness. The description adds the optional SSH-wait behavior, which is useful, but it does not explain timeout handling, wait_ip behavior, or what happens if the VM is already running.

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?

One compact, front-loaded sentence with no filler. The key action and the optional waiting behavior are stated directly and efficiently.

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 state-changing tool with four parameters, zero schema descriptions, and no output schema, the single sentence leaves important operational details unstated: the meaning of wait_ip, timeout scope, the return value, and behavior when the VM is already running. Annotations cover safety but not operational 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 carry parameter meaning. It only hints at wait_ssh via 'attend optionnellement que SSH soit accessible' and does not clarify vm_name, timeout, or wait_ip 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 states a specific action ('Démarre' / starts) on a specific resource ('VM KVM') and adds an optional waiting behavior for SSH. This clearly distinguishes it from sibling tools like vm_stop, vm_destroy, and vm_status.

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 tool's purpose implies that it is used to start a VM, but the description gives no explicit guidance on when to choose it over alternatives, no prerequisites, and no exclusions such as 'use vm_status to check state' or 'use vm_verify to check accessibility'. Usage context is only implied.

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 already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the bar is lower. The description adds useful context: the information categories returned (IP, SSH, resources) and the list-all behavior without vm_name. But it does not disclose return formatting, pagination, or error behavior, which the absence of an output schema would warrant.

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 short, front-loaded sentences with zero wasted words. The primary function and information scope appear first, and the optional-parameter behavior is added second. 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?

For a simple read-only tool with strong annotations, the core behavior is well covered: what it shows, the listing fallback, and the safe/idempotent profile. The gaps are the fully unexplained json/detailed parameters and the lack of any return-format details given that no output schema exists. An agent can call it correctly for the basic case, but not confidently for the optional flags.

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 adds real meaning for vm_name only (its omission triggers a full listing). The 'json' and 'detailed' parameters receive no semantic explanation anywhere, leaving an agent to guess at their effect. With two of three parameters undocumented, the compensation is only partial.

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 (Affiche = displays), a resource (VM), and the exact scope of information (status, IP, SSH, resources). It also covers the no-vm_name fallback behavior (lists all VMs). This cleanly distinguishes it from the action-oriented siblings (vm_start, vm_stop, vm_destroy, vm_exec) and from backup_status, which is scoped to backups.

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 contextual guidance on parameter usage: 'Sans vm_name, liste toutes les VMs' tells the agent when omitting the argument changes the behavior. However, it never names alternatives or states when-not-to-use it versus siblings such as vm_verify, so tool-selection guidance is only implied rather than explicit.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description's warning aligns with them. The description adds value by specifying graceful vs forced stop behavior and the --force flag, which goes beyond the schema. No contradiction with 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?

The description is short and front-loaded with the action and warning. The warning is prominent and useful. It could be slightly more structured, but it earns its place with the key information.

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

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

For a destructive operation with no output schema, the description should clarify return values, side effects, and the difference between graceful and forced stop. It covers the destructive nature and force option, but lacks details on what happens to the VM state, whether wait/timeout affect behavior, and what the tool returns. Given the complexity and destructive nature, this is a moderate gap.

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. However, the description only mentions vm_name implicitly and the --force flag, leaving wait, timeout, and the exact semantics of force underdocumented. The schema provides types and defaults, but the description adds minimal meaning beyond the action itself.

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

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

The description clearly states the tool stops a KVM VM gracefully or forcefully with --force, and includes a warning about potential destructiveness. It distinguishes the action from siblings like vm_destroy and vm_start, though it doesn't explicitly name 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?

The description implies usage for stopping a VM and mentions the force option, but it doesn't explicitly state when to use this tool versus vm_destroy or other alternatives. The warning about destructiveness gives some context, but no clear when-to-use or when-not-to-use guidance is provided.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the verification target but does not disclose what checks are performed, what output is produced, or how flags like quick or save_report affect behavior.

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

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

The description is a single front-loaded sentence with no wasted words. It is concise, though for a tool with 9 parameters and no output schema it is arguably too sparse to be fully 'appropriately sized.'

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

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

The tool has no output schema and 9 parameters, but the description only communicates the high-level purpose. Missing details include what success/failure looks like, what 'faithful copy' means operationally, how the comparison flags alter behavior, and whether a report is generated.

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 mentions none of the 9 parameters. The meaningful flags (compare_content, compare_packages, self_check, save_report, quick, verbose) receive no explanation, so the agent must guess their semantics from names alone.

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 ('Vérifie') and resource (a cloned VM vs. the host system), making the tool's core purpose clear. It does not explicitly contrast with siblings like backup_verify, but the object of verification is distinct enough to avoid confusion.

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?

Usage is implied: this tool is for verifying that a cloned VM faithfully matches its host, presumably after cloning. There is no explicit guidance on when not to use it or which sibling alternative (e.g., backup_verify) to choose instead.

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