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

Annotations already declare readOnly=false, openWorld=true, idempotent=false, destructive=false, so the safety profile is covered. The description adds nothing beyond that: it does not say whether a backup overwrites existing archives, where it runs, whether it requires credentials, or how long it may take on large trees.

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?

It is very short, but the second sentence is generic filler that adds no usable information, and the useful signal (that this backs up files) is not expanded at all. Brevity here is under-specification rather than 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?

A complex, 24-parameter, open-world mutation tool with no required params and no output explanation needed (output schema exists) still requires the description to state what gets backed up, from where, to where, and under what auth — none of which is present.

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 100%, so the 24 parameters are documented individually and the baseline is 3. However, the description does nothing to disambiguate the mixed-operation parameter set (backup_paths, backup_dest, compression, incremental vs. content_search/watch/diff params) — a real missed opportunity given how confusing the schema is.

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 title/name is restated ("Backup (tm_files)") and the only elaboration, "Advanced file operations on remote hosts," describes the whole tm_file_* family rather than this tool. An agent cannot tell from this text how backup differs from tm_file_recursive_ops or tm_remote_send_file.

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 when-to-use statement, no mention of alternatives such as tm_remote_send_file for a one-off transfer, and no stated prerequisites (SSH connectivity, remote_host/username requirements). The agent must infer everything 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, openWorldHint=true, and destructiveHint=false. The description adds only the vague notion of 'advanced file operations on remote hosts' and does not disclose authentication needs, parameter scoping, or which operations the tool actually performs.

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 definition is short and front-loads 'Content search,' but the second sentence is generic and arguably misleading given the tool's focused name. It is concise, but at the cost of useful specificity.

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 complex 24-parameter tool with zero required parameters, many parameters belonging to unrelated operations, and no description of SSH/auth expectations. An output schema exists, so return values need not be explained, but the description still does not provide enough context to call the tool confidently.

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 100%, so the schema itself documents every parameter. The description adds no parameter semantics, and it does not clarify why a content-search tool exposes parameters for backup, diff, watch, and recursive file operations.

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

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

The description identifies content search in parentheses and mentions remote hosts, but it immediately broadens to 'Advanced file operations,' which is vague and does not distinguish this tool from adjacent file-operation siblings such as tm_file_recursive_ops, tm_file_watch, tm_file_diff_compare, and tm_file_backup.

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 explicit guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The name implies content search, but the description never says how that differs from the other file-system 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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that – no mention of SSH auth requirements (username, identity_file, password_ref), no disclosure of what a diff returns or how hosts are reached. "Advanced file operations" is loose enough to imply mutation, which sits awkwardly against readOnlyHint=true, though it never explicitly claims a write.

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 sentences, so it is not bloated, but the second sentence earns nothing and actively dilutes the diff-compare focus. Front-loading is fine; the content is the problem, not the length.

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 24 optional parameters drawn from six different operations and no required fields, the agent needs the description to say which subset applies to diff compare and what the comparison result looks like. An output schema and annotations exist, which relieves some burden, but the description still leaves the core calling pattern unexplained.

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 100%, so the schema already documents all 24 parameters and the baseline is 3. The description's only gesture toward parameters is "remote hosts," which hints at host1/host2 but adds no real semantics. Notably it does not disambiguate the union schema – an agent must infer from the schema's own parentheticals that only host1, host2, and file_path matter here.

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?

"Diff compare (tm_files)" simply restates the tool name, and the follow-on "Advanced file operations on remote hosts" is a vague catch-all that gives no specific verb+resource beyond the title. It never says what is compared (host1 vs host2, or file_path across hosts), so an agent learns nothing it didn't already get from the name.

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

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

There is no when-to-use guidance at all, despite a dense sibling set (tm_file_recursive_ops, tm_file_content_search, tm_file_watch, tm_file_backup) that all share this same 24-parameter union schema. Nothing tells the agent to pick this tool for host-to-host diffing rather than the other tm_file_* 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?

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false, so the safety profile is partly covered. The description adds nothing beyond that: it doesn't say the operations run over SSH, that credentials come from username/identity_file/password_ref, or that some operations (delete, move) mutate or remove remote files. Given destructive operations are reachable, silence on irreversibility is a real gap.

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 two fragments are short but not concise in the useful sense: for a 24-parameter, multi-operation surface there is no structure, no grouping by operation, and no front-loaded statement of the primary mode. It is under-specification rather than economy.

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 24-parameter tool that multiplexes copy/move/delete/list/chmod/chown plus search, backup, diff, and watch parameters, two sentences of boilerplate leave an agent without the information needed to call it correctly. The output schema covers return values, but the selection logic across operations is entirely absent.

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 100%, so the baseline is 3; each parameter is already tagged in the schema with the sub-operation it belongs to (recursive_ops, content_search, backup, diff_compare, watch). The description adds no meaning on top of that, notably not explaining that 'operation' is the discriminator that determines which of the 24 parameters matter.

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?

"Recursive ops (tm_files). Advanced file operations on remote hosts." mostly restates the tool name and title; "advanced file operations" names no specific verb or resource scope. An agent cannot tell from this whether the tool copies, deletes, chmods, or backs up, and cannot distinguish it from siblings such as tm_file_backup or tm_file_content_search, which the schema itself shows are folded in here.

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 when-to-use guidance, no prerequisites, and no mention of any alternative tool. With a dozen siblings covering file search, backup, diff, watch, and remote file transfer, the description offers no basis for routing a request to this tool rather than those.

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 state readOnlyHint=false, idempotentHint=false, openWorldHint=true, so the safety profile is partly covered, but the description adds nothing: it doesn't explain that watching monitors paths for a duration, what triggers a result, whether the session blocks, or what credentials are needed (username/identity_file/password_ref in the schema go unmentioned).

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?

It is short and front-loaded, but the second sentence ("Advanced file operations on remote hosts") is filler that doesn't earn its place and arguably mischaracterizes a watching tool as a general file-operations 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?

A 24-parameter tool with an output schema and openWorld/destructive annotations needs the description to at least explain the watch behavior and scope; instead it supplies one tautology and one generic clause, leaving an agent unable to tell what this call actually does.

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 100%, so the baseline is 3. The description adds no meaning, and given the schema is a 24-parameter union spanning watch/recursive_ops/backup/diff/search, guidance on which parameters apply to Watch (watch_paths, duration, remote_host) would have been highly valuable.

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?

"Watch (tm_files)" essentially restates the tool name and title, and "Advanced file operations on remote hosts" is a vague generic phrase that describes the whole tm_file_* family, not this tool. Nothing distinguishes watching files from siblings like tm_file_diff_compare, tm_file_backup, or tm_file_content_search.

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 indication of when to use Watch instead of the many sibling file tools, no prerequisites, and no exclusions. The only implied context is the generic "remote hosts," which applies equally to every sibling.

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 declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, but the description adds nothing to them: it never states that SSH keys are written to files or hosts, that a target group is contacted over the network, whether existing keys are overwritten, or what authorization is needed. Its second sentence even broadens the claimed scope to 'bulk inventory operations', which is a different behavior from key auth.

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 only two short sentences, so it has no verbosity problem. However, the second sentence is generic family boilerplate that conflicts with the operation name, so it does not earn its place and actively misdirects rather than front-loading useful scope.

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 16-parameter, multi-mode tool that writes SSH keys into an inventory, two sentences are far too thin. The output schema exists, so return values need not be explained, but the description still omits which parameter selects which operation and what the tool actually changes on disk or across hosts.

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 100%, and the schema's parameter text (notably for 'host' and 'preview') is far richer than the description, so the baseline of 3 applies. The description adds nothing about parameter semantics and does not explain the multi-operation dispatch that its 16 flat parameters imply.

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 first sentence, "Configure key auth (tm_inventory)," simply restates the tool name and title. The second sentence, "Bulk inventory operations against YAML host groups," describes the whole inventory tool family rather than this key-auth operation, and it conflicts with the name; it does not distinguish this tool from siblings such as tm_inventory_rotate_key, tm_inventory_copy_ssh_config, tm_remote_setup_passwordless, or tm_remote_test_key_auth.

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

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

The description contains no when-to-use guidance, no prerequisites, and no named alternative. Nothing tells the agent why it would pick this over tm_remote_test_key_auth or tm_remote_setup_passwordless, and it never explains that the 16 parameters are mode-selecting (key vs cmd vs cfg vs lpath), so an agent cannot infer what to call from the text.

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=false, idempotentHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is partly covered. The description adds nothing beyond that: it does not say that copying a config overwrites rmt_cfg, whether an existing remote config is backed up, whether auth/prerequisites are required, or how failures across a host group are handled. For a mutation tool with a non-idempotent flag, that is a real gap.

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?

It is short and front-loaded, so there is no bloat. But the second sentence does not earn its place: it restates the inventory family theme without adding scope, direction, or constraints. Being terse here is under-specification rather than effective conciseness.

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?

An output schema exists, so return values need not be explained. Still, for a 16-parameter mutation tool in a family of look-alike siblings, the description omits the copy direction, which parameters actually apply, and the group fan-out semantics. An agent cannot reliably invoke this from the description alone.

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 100%, so the baseline is 3 and the schema carries the parameter burden. The description contributes nothing to disambiguate the 16 shared parameters, several of which belong to other tools (cmd, lpath, key_pfx), so it neither adds meaning nor compensates for the ambiguity an agent faces when picking cfg vs rmt_cfg.

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 first sentence names a specific verb and resource ("Copy ssh config"), which is better than a tautology. However, it does not distinguish this tool from the direct sibling tm_remote_copy_ssh_config, and it never says whether the copy goes local-to-remote or remote-to-local. The second sentence ("Bulk inventory operations against YAML host groups") is generic family boilerplate rather than a scope statement for this specific tool.

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

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

There is no when-to-use guidance and no named alternative, even though tm_remote_copy_ssh_config is an obvious sibling that an agent must choose between. The phrase "Bulk inventory operations against YAML host groups" hints at the group-based scenario but never states it as a selection criterion or gives a when-not.

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 declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true, so the description still needs to explain what actually mutates. It does not: nothing indicates that setting 'key_pfx' creates new keypairs (rotate_key), that 'cfg'/'rmt_cfg' rewrite remote SSH config, or that 'preview' is the only safe dry-run. The schema carries this information, not the description.

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 with no filler and no buried content, so it is efficient in form. But 'appropriately sized' is not met: a 16-parameter, six-mode dispatch tool compressed to one sentence of noun phrase leaves the reader less informed than the name plus schema alone.

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?

An output schema exists, so return values need not be explained, but the description still omits the operation-selection logic, the fan-out scope, and the fact that multiple behaviors live behind one entry point. For a zero-required-parameter tool where the caller must set the right combination to get a given operation, that is a material 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 100%, so the schema already documents all 16 parameters, including host precedence, preview semantics, and resolved_hosts. The description adds no parameter meaning at all – not even which parameter selects which operation – so it sits at the baseline for fully documented schemas.

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 says 'Bulk inventory operations against YAML host groups', which is a vague restatement of the name rather than a specific verb+resource. The tool actually dispatches six distinct operations (run_command, send_file, receive_file, copy_ssh_config, rotate_key, configure_key_auth), but none of them are named, so an agent cannot tell what this does apart from tm_inventory_run_command or tm_inventory_send_file.

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 when-to-use, when-not-to-use, or alternative is mentioned, even though the sibling list contains single-operation counterparts for every capability this tool bundles. The only implicit hint is the word 'bulk', which hints at fan-out scope but does not give the agent any rule for choosing this tool over a sibling.

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 declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the agent already knows this is a non-idempotent, non-destructive outward-facing operation. The description adds nothing: it does not say whether existing local files are overwritten, how fan-out across the group is handled, what happens on partial failure, or how parallel/max_threads 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 short and front-loaded, so it is not bloated, but the second sentence is boilerplate shared with the whole tm_inventory family and carries no tool-specific information. It is concise without being informative.

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 16-parameter file-transfer tool with no required parameters, no enum constraints, and a schema salted with run_command-only options, the description needed to say at minimum which parameters govern a receive_file call and what the source/target semantics are. It supplies none of that; even the existence of an output schema does not compensate for the missing operational contract.

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 100%, so the 16 parameters are documented in the schema itself and the baseline of 3 applies. The description contributes no additional parameter meaning, and notably several schema entries (host, preview, cmd) are scoped to "run_command only", leaving the agent to infer which of the 16 knobs actually matter for a receive-file 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 restates the tool name ("Receive file") and adds only a generic family tagline, "Bulk inventory operations against YAML host groups." It never says receive a file from which inventory host(s) to where locally, nor how this differs from the sibling tm_remote_receive_file or from tm_inventory_send_file. An agent can guess the general area but not the specific 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?

There is no when-to-use guidance, no exclusion, and no mention of alternatives such as tm_remote_receive_file (single host) or tm_inventory_send_file (opposite direction). With 38 sibling tools in the same listing, the absence of any routing signal is a real gap.

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, idempotentHint=true and openWorldHint=true, so the description is not required to establish the safety profile. It nonetheless adds nothing beyond them: it never says whether old keys are replaced or preserved, whether authorized_keys/config entries are rewritten, whether backups exist, or how failure mid-fan-out is handled — all material for a destructive key-rotation 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 text is short, but brevity here reflects under-specification rather than economy. The second sentence does not earn its place — it is a vague, potentially misleading scope statement that occupies half of the 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?

An output schema and rich annotations exist, which relieves the description of return-value and safety explanation, but a 16-parameter destructive operation still needs the rotation flow described (target group resolution, new key generation, replacement semantics). The description supplies none of that, leaving the agent to infer behavior entirely from parameter names.

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 100% across all 16 parameters, so the schema fully documents them and the correct baseline is 3. The description itself contributes no additional parameter meaning; notably it never indicates which of the 16 parameters actually drive rotation (key_pfx, key_type, group, inventory) versus the many borrowed from sibling operations.

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 title and first two words restate the tool name ('Rotate key'), adding no distinguishing detail. The trailing sentence, 'Bulk inventory operations against YAML host groups,' is a generic scope claim that could equally describe tm_inventory_run_command, tm_inventory_send_file or tm_inventory_copy_ssh_config, and it obscures rather than clarifies what rotation does.

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 statement of when to use this over tm_remote_rotate_key or the other tm_inventory_* siblings, and no prerequisites (existing key auth, inventory reachability) or exclusions. The only hint of usage comes incidentally from the schema text of 'key_pfx', not from the description.

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=false, openWorldHint=true and non-idempotent, which tells the agent this mutates remote state. The description adds nothing beyond that: no mention of fan-out blast radius, no warning that cmd is arbitrary shell, no reference to preview/scope verification, and no timeout behavior — all of which are the key risks for this 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?

Two short sentences with the name restated first, so it is front-loaded and wastes few words. However, the only content sentence ("Bulk inventory operations against YAML host groups") is vague enough that brevity tips into under-specification.

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 16-parameter tool that executes arbitrary shell commands across many hosts, the description says nothing about the single-host vs group targeting model, the preview safety path, or the risk of unintended fan-out. An output schema and rich parameter docs exist, but they don't substitute for a warning about what this tool actually does at scale.

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 100%, and the schema itself is unusually rich (host vs group precedence, preview semantics, timeout, parallel/max_threads are all documented inline). The description adds no parameter meaning at all, so the baseline 3 for high coverage applies.

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 verb+resource is present ("Run command"), and "against YAML host groups" hints at the fan-out scope that distinguishes it from tm_remote_run_command. But "Bulk inventory operations" is vague and doesn't say the tool executes a shell command over SSH across a group of hosts, so the agent must infer the actual behavior.

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?

Nothing says when to use this instead of tm_remote_run_command or the other tm_inventory_* siblings. The word "bulk" implies the fan-out case, but there are no explicit conditions, prerequisites, or exclusions given.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, so the safety profile is partly covered. The description adds no behavioral context such as whether files are overwritten, what permissions are required, or how the inventory fan-out affects execution.

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 only two short sentences and front-loads the action 'Send file'. The second sentence is generic but does provide inventory scope context, and there is no wasted 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?

This is a 16-parameter, open-world, non-idempotent inventory operation with many siblings, and the description gives almost no operational context. The schema and annotations cover structure and safety hints, but the description does not explain usage, alternatives, or file-transfer 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?

Schema description coverage is 100%, so all 16 parameters are documented in the input schema. The description adds no parameter-level meaning beyond what the schema already provides, which matches the baseline of 3 when the schema carries parameter 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 repeats the tool name/title with 'Send file (tm_inventory)' and adds a broad phrase about bulk inventory operations against YAML host groups. It does not clarify what sending a file entails, such as copying a local path to remote hosts selected from inventory, and it does not distinguish this from sibling tm_remote_send_file.

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 explicit guidance on when to use this tool versus tm_remote_send_file or tm_inventory_receive_file. The phrase 'Bulk inventory operations against YAML host groups' hints at inventory scope, but no conditions, exclusions, or alternatives are stated.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so an agent knows cancelling has side effects and is repeatable. The description adds nothing beyond that — it does not state that cancellation is irreversible, what happens to in-flight work, or whether partial results are discarded, which are the questions an agent actually has for a destructive lifecycle call.

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?

It is short, but the second sentence does no work — it is a taxonomy label rather than an actionable statement, and the only informative token ("Cancel") is diluted by it. Length is not the problem; the filler is.

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 destructive, open-world lifecycle mutation with nested details, an output schema, and four optional-defaulted parameters. For that complexity, the description omits the target selection, the effect of cancellation, and how it relates to the other tm_operation_* tools.

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 100%, so all four parameters are documented in the schema (notably operation_id for get_progress/cancel/get_metrics). The description adds no extra meaning, such as which parameter actually selects the operation to cancel, so baseline 3 applies.

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 fragment "Cancel (tm_operations)" names a verb and the resource family, so an agent can guess it terminates an operation. But the second sentence, "Operation lifecycle and session management," is a category label that could describe start, get_progress, or get_metrics equally, so it does not distinguish this tool from its closest siblings.

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

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

There is no guidance on when to cancel versus when to check progress (tm_operation_get_progress) or start a new operation (tm_operation_start). No prerequisites, no mention that an operation_id must identify the target, and nothing about what happens to already-completed steps.

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, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered by structured data. The description adds nothing on top of that: no indication of what metric families come back, whether results are aggregated per operation or across sessions, or whether any auth/scope applies.

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?

It is short and front-loaded, but the second fragment ("Operation lifecycle and session management") does not earn its place because it conveys no actionable information about this tool. Brevity here comes from under-specification rather than disciplined editing.

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?

An output schema exists, so return-value explanation is not required, but the tool takes a nested free-form details object plus an operation_id with no indication of expected shape or defaults being empty. For a metrics-lookup tool sitting among several operation-lifecycle siblings, the description leaves too much for the agent to infer.

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 100%, so the schema already documents all four parameters (including the note that operation_id is shared with get_progress/cancel), which sets the baseline at 3. The description contributes no additional meaning about how operation_id, operation_type, total_steps or the nested details object affect the metrics returned.

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?

"Get metrics (tm_operations)" mostly restates the tool name and title, and the follow-up "Operation lifecycle and session management" reads as a category label rather than a statement of what is being retrieved. It never says whose metrics, at what granularity, or how this differs from tm_operation_get_progress, so an agent cannot distinguish the two from the description alone.

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 when-to-use guidance or exclusion. The sibling set contains an obvious alternative (tm_operation_get_progress) and a session lister (tm_operation_list_sessions), but the description offers nothing about which one to pick or what prerequisite (a valid operation_id) is needed first.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that: it doesn't explain what happens with the empty default operation_id, whether an unknown operation yields an error or empty result, or what the progress payload represents.

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?

It is short and front-loaded, but the second sentence ('Operation lifecycle and session management') is generic filler that earns no place—it neither scopes the tool nor routes to an alternative.

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?

An output schema exists, so return values needn't be explained, and annotations cover the read-only safety profile. Still, for a read tool with an ambiguous empty-default operation_id and several start-oriented parameters, the description leaves real gaps about invocation correctness.

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 100%, so the four parameters are documented structurally, which sets the baseline at 3. However, the description does not clarify the confusing presence of start-only parameters (operation_type, total_steps, details) in a get-progress schema, so it adds no value over 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 verb+resource ('Get progress') is identifiable, and the parenthetical 'tm_operations' names the domain. But 'Operation lifecycle and session management' is vague filler that doesn't say what progress data is actually retrieved, and it doesn't distinguish this tool from siblings like tm_operation_get_metrics or tm_operation_list_sessions.

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 call this versus tm_operation_get_metrics or tm_operation_list_sessions, nor any prerequisite such as needing a valid operation_id from tm_operation_start. The agent must infer usage entirely from the tool 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, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds nothing behavioral beyond that – no mention of scope, filtering, pagination, or what a "session" contains – so it contributes no value on top of the structured 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?

It is short and front-loaded with the verb and resource, but the second sentence ("Operation lifecycle and session management") is filler that adds ambiguity rather than information, so not 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?

An output schema exists and annotations are rich, so return values and safety needn't be explained. However, the description never clarifies what a "session" is in this system or how listing differs from the operation lifecycle tools, leaving a real gap for an agent deciding whether to call it.

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

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

Schema coverage is 100%, so all four parameters are documented in the schema, which sets the baseline at 3. The description adds no parameter meaning (e.g., which params actually apply to a list operation versus start/get_progress), so it neither helps nor 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?

"List sessions (tm_operations)" gives a clear verb and resource, but the follow-up "Operation lifecycle and session management" is vague and actually describes the operation family rather than this tool, leaving it poorly distinguished from siblings like tm_operation_get_progress or tm_operation_start.

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 indication of when to list sessions versus using the other tm_operation_* tools, and no prerequisites or context for choosing this tool over sibling alternatives are 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 state readOnlyHint=false, idempotentHint=false, openWorldHint=true, and destructiveHint=false. The description adds no behavioral context such as whether starting creates persistent state, requires permissions, emits side effects, or how sessions relate to operations.

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?

It is very short and front-loads 'Start,' but the second fragment is a vague category label rather than useful structure. It avoids fluff but is under-specified for an operation-start 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?

Although an output schema exists and annotations cover safety hints, the description does not explain what starting an operation does, how session state is affected, or how this tool fits the lifecycle. For a non-idempotent, open-world mutation, this leaves 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 100%, and the schema documents all four parameters, so the baseline is 3. The description itself adds no parameter meaning beyond the schema, particularly for operation_type, total_steps, and 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 name and title already say 'Start'; the description repeats that and adds only the broad category 'Operation lifecycle and session management.' It does not specify what is being started, what an operation represents, or how this differs from siblings like get_progress or cancel.

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 explicit guidance on when to use this tool versus sibling operation tools, nor any prerequisites or when-not-to-use conditions. 'Operation lifecycle and session management' is too vague to route an agent among start, get_progress, cancel, get_metrics, or list_sessions.

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, destructiveHint=false, idempotentHint=true, and openWorldHint=true, so the description need not repeat safety metadata. However, it adds almost no behavioral context: it does not clarify whether this is a diagnostic check, a command runner, a file-transfer helper, or a multiplexed operation surface, despite schema fields for run_command, send_file/receive_file, rotate_key, and remove_host_key.

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, but the first sentence mostly repeats the tool name and the second is a generic phrase. It is concise without being informative, so it earns a middling score rather than high marks.

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 19 parameters, many operation-specific fields, no required params, and a rich sibling set, the description is far too sparse to orient an agent. An output schema exists, so return values need not be explained, but the description should at least clarify the tool's operational scope and relationship to the more specific SSH siblings.

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 100%, with all 19 parameters documented in the schema, so the description does not need to explain individual parameters. The description adds only the general notion of 'shared connection params' and provides no additional meaning beyond the schema, which meets the baseline for high-coverage schemas.

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 largely restates the name and title: 'Check ssh (tm_remote)' plus the vague phrase 'Single-host SSH operations with shared connection params.' It does not specify what 'check' actually does or distinguish this tool from the many specific SSH siblings such as tm_remote_run_command, tm_remote_send_file, or tm_remote_rotate_key.

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 any of the sibling SSH tools. The phrase 'Single-host SSH operations' implies broad usage but gives no exclusions, prerequisites, or alternative-routing advice despite an extensive sibling list.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is partly known. The description adds no behavioral context such as whether the remote SSH config is overwritten, what permissions are required, or what happens on failure.

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-loads the action, which is good. The second sentence is somewhat generic filler, but it does not bloat the description.

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

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

Given a 19-parameter schema and a mutating copy operation, the description is too sparse to be complete. It does not clarify which shared params are relevant to copy_ssh_config, how it differs from the inventory variant, or what the operation modifies; an output schema helps with return values but not with invocation context.

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

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

Schema description coverage is 100%, so all 19 parameters are documented in the schema itself. The description only mentions 'shared connection params' without adding meaning to any specific parameter, so the baseline of 3 applies.

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 first sentence states a specific verb and resource ('Copy ssh config') and scopes it with '(tm_remote)', so the basic operation is clear. However, the second sentence is generic and does not distinguish this tool from tm_inventory_copy_ssh_config or explain that the 19-param schema is a shared parameter set rather than a multi-operation tool.

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

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

No guidance is given on when to use this tool versus tm_inventory_copy_ssh_config or the other tm_remote_* siblings. The phrase 'Single-host SSH operations' hints at a single-host scope but never states the alternative (inventory-wide copy) or any prerequisites.

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=false, idempotentHint=false, destructiveHint=false, openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that — it doesn't say whether an existing local file is overwritten (a non-idempotent write to disk), how partial transfers behave, or that credentials come from the shared SSH params. For a non-idempotent file write, an overwrite/clobber note would be the key context an agent needs.

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?

Short and front-loaded, so it reads easily. But the second sentence is generic family boilerplate that doesn't earn its place in a tool-specific definition, and the space it occupies would have been better used on direction of transfer or overwrite behavior.

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?

Nineteen parameters, no required fields, and an output schema mean the description should at minimum orient the agent: set rpath as source and lpath as destination, host as target, and warn that the local file may be overwritten. None of that is present, and direction of the transfer — the single most decision-relevant fact — is unstated. The schema fills the parameter gaps, but the core operational semantics are 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 100%, so lpath/rpath/host/user/port etc. are already documented in the schema, making 3 the baseline. The description's only parameter-adjacent claim — 'shared connection params' — doesn't add format, defaults, or constraints beyond the schema. It also doesn't point the agent at lpath/rpath as the operative parameters for this tool.

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?

"Receive file (tm_remote)" essentially restates the tool name and title without saying which direction data flows (remote→local download vs. local→remote upload). The second sentence, "Single-host SSH operations with shared connection params," is generic scope boilerplate that applies to the whole tm_remote family, not this tool. With tm_remote_send_file as a sibling, this leaves the agent to infer the direction of transfer.

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 when-to-use guidance at all: nothing distinguishes this from tm_remote_send_file or tm_inventory_receive_file, and no prerequisites (reachable host, existing key, target path writability) are stated. The only framing is generic 'single-host SSH operations' coverage which applies to every sibling.

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 destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds no further behavioral context such as which known_hosts file is affected, whether confirmation is required, or what exactly gets removed.

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-loads the action: 'Remove host key (tm_remote).' The second sentence is somewhat generic boilerplate, but the overall structure is efficient and wastes little 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?

For a destructive tool with 19 parameters, the description is too thin. Even though annotations and schema are rich, it does not mention the host-key storage target, the confirm behavior, or how host selection relates to the operation, leaving important context to the schema alone.

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 100%, so all 19 parameters are documented in the schema itself. The description only mentions 'shared connection params' and adds no extra parameter meaning beyond what the schema already provides, which matches the baseline of 3 for high schema coverage.

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

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

The description states a specific verb and resource: 'Remove host key,' so the action is immediately clear. It identifies the tm_remote module but does not differentiate from siblings such as tm_remote_rotate_key or tm_remote_check_ssh, which is why it falls short of 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?

It gives no explicit guidance on when to use this tool versus alternatives like rotate_key or check_ssh. The phrase 'Single-host SSH operations with shared connection params' implies context but does not tell the agent when removal is appropriate or what prerequisites exist.

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, idempotentHint=true and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond that: it never says whether the old key is replaced or backed up, whether confirm is needed, or what happens on failure. For a destructive mutation, that is a real gap.

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 sentences, no padding, and the operation name is front-loaded. But the second sentence is generic boilerplate about shared connection params and earns little of its 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?

With 19 parameters, most of which belong to other operations in this shared-param group, the description gives no help identifying the handful relevant to rotation (host, new_key, key_type, port, user). An output schema exists, so return values needn't be covered, but the parameter scoping gap is significant for a destructive 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 100%, and each parameter already carries its own note (e.g., "New private key path (rotate_key)", key_type values). Baseline 3 applies – the description adds no syntax, defaults, or interaction rules 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?

"Rotate key" names a verb and resource, but leaves the object ambiguous: which key (SSH private key on the remote host?), and what rotation entails. The parenthetical "(tm_remote)" scopes it to single-host operation, which faintly separates it from tm_inventory_rotate_key, but nothing explicitly distinguishes the two.

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?

"Single-host SSH operations" implies the condition for choosing this over the inventory variant, but the agent must infer that. There is no explicit when-to-use, when-not, or prerequisite statement (e.g., that the remote must already be reachable and key-auth configured).

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=false, destructiveHint=false, openWorldHint=true, and idempotentHint=false, so the safety profile is covered. The description adds only the vague phrase 'shared connection params' and says nothing about execution side effects, privilege level, timeout behavior, or what happens when the remote command fails.

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 filler. It is efficient, though the terseness is a shortfall captured under contextual completeness rather than a structure problem.

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 19-parameter tool where only a handful apply to command execution; the description never says which, so an agent must reverse-engineer intent from per-param 'used by X' notes. Output schema and annotations cover returns and safety, but the core question of which params matter for this call is left unanswered.

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 100%, so every one of the 19 parameters is documented inline and the baseline is 3. The description does not identify which parameters (cmd, host, timeout) actually drive a run_command call, so it adds no 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?

States a specific verb and resource (run a shell command over SSH) and scopes it to a single host, which implicitly contrasts with the bulk tm_inventory_run_command sibling. It stops short of naming that sibling explicitly, so the differentiation is inferable rather than stated.

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

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

There is no guidance on when to use this versus tm_inventory_run_command, tm_remote_check_ssh, or the send/receive_file siblings. 'Single-host' is the only routing hint, and it is never framed as a selection criterion.

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 disclose readOnlyHint=false, destructiveHint=false, openWorldHint=true, and idempotentHint=false, so the safety profile is partly covered. The description adds almost no behavioral context beyond calling it a 'send file' operation—nothing about overwrite behavior, required permissions, authentication, or transfer semantics. For a file-transfer mutation, this is a meaningful gap.

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 short fragments with no filler, and the key verb-resource pairing is front-loaded. It is not padded, though the terseness contributes to the completeness gaps elsewhere.

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 19 parameters, an output schema, and the complexity of SSH file transfer, the description is far too thin. Even with rich schema and annotations, an agent needs at least minimal context on direction, overwrite behavior, or how this differs from receive_file and inventory-based send 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 100%, so all 19 parameters are documented in the schema and the description need not repeat them. The description contributes no additional parameter meaning beyond the shared-connection-params phrase, which is appropriate for a baseline 3 when the schema does the heavy lifting.

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 ('Send file') and vaguely situates it in 'single-host SSH operations,' which hints at scope. However, it does not distinguish this tool from close siblings like tm_remote_receive_file or tm_inventory_send_file, and the parenthetical '(tm_remote)' mostly repeats the name prefix rather than adding meaning. Purpose is identifiable but under-specified.

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 the many file-transfer siblings, nor any prerequisites, directionality, or exclusions. The phrase 'Single-host SSH operations with shared connection params' describes the family, not a decision criterion for invoking this specific 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?

Annotations only declare readOnly=false, openWorld=true, idempotent=false, destructive=false. The description does not disclose what is mutated on the remote (authorized_keys), that password_ref may be required for the initial password auth, whether re-running is safe, or that it touches the network. For a 19-parameter mutation tool, the burden shifts to the description and it does not carry it. 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?

It is short and front-loaded, but the second sentence is generic boilerplate about the tm_remote family rather than insight about this tool, so a sentence that could clarify behavior instead dilutes the 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?

With 19 optional parameters, a mutating operation, and a long list of closely-related siblings, the description should explain the core flow and the role of the shared connection params. It doesn't. An output schema exists, so return values need not be covered, but the operational story is missing.

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

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

Schema description coverage is 100%, so all 19 parameters are documented in-schema, which sets the baseline at 3. The description adds no meaning beyond those fields, but it is not required to given full coverage.

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

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

The description restates the name ("Setup passwordless") and adds only a scope tag, "(tm_remote)", plus "Single-host SSH operations with shared connection params." The single-host qualifier weakly separates it from the tm_inventory_* siblings, but it never says what the tool actually does (generate a keypair, install the public key in the remote's authorized_keys) or how it differs from tm_remote_test_key_auth or tm_inventory_configure_key_auth.

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?

"Single-host" implies a scope, but there is no explicit when-to-use, no prerequisite (e.g. an existing SSH password in password_ref), and no named alternative to choose instead for multi-host or verification workflows among the many 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so safety is covered. The description adds nothing beyond that: it doesn't say what a failing auth result looks like, whether any remote state is touched, whether credentials are read from disk, or how long the probe may take. "Shared connection params" hints at the schema but conveys no 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?

It is short, but the second sentence does not earn its place: it describes the input schema generically instead of telling the agent what the tool does or when to call it. Brevity without front-loaded substance.

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 19-parameter tool with a large sibling family, and the description leaves the agent unable to tell which parameters are relevant or how this differs from adjacent SSH tools. The output schema exists, so return values needn't be explained, but purpose and usage gaps remain large for a tool of this 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 100% and each parameter's description tags which operation it belongs to (e.g. "Key path (test_key_auth/setup_passwordless)", "New private key path (rotate_key)"), so the schema does the disambiguating work. The description contributes only the vague phrase "shared connection params" and does not clarify which of the 19 parameters actually matter here.

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?

"Test key auth" restates the tool name and title almost verbatim, adding essentially no verb/resource specificity. "Single-host SSH operations with shared connection params" describes the schema shape rather than the action, and gives no way to distinguish this from siblings like tm_remote_check_ssh or tm_inventory_configure_key_auth.

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 when-to-use or when-not guidance. The agent is not told whether this is a pre-flight probe before setup_passwordless, a post-change verification, or how it differs from check_ssh. Nothing is stated or even implied beyond 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, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered elsewhere. The description adds nothing new: it does not mention SSH authentication requirements, what the audit returns, or that it reaches out to remote_host.

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?

It is short and front-loaded, so it satisfies the conciseness test, but the brevity comes at the cost of under-specification rather than tight information density.

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 remote-host audit with SSH credentials (password_ref, identity_file) and an output schema, the description should say what happens on the remote host and what result is returned. It leaves all of that to the schema and annotations.

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 100% and every parameter has its own description including defaults and allowed values, so the schema carries the full burden. The description contributes zero parameter meaning, which is the baseline-3 case when coverage is high.

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 paraphrases the title: 'Access control audit (tm_security). Security scanning and compliance.' It names no verb-specific scope and never distinguishes this tool from close siblings like tm_security_security_audit, tm_security_compliance_check, or tm_security_vulnerability_scan, which the schema parameters (scope, standard, scan_type) hint this tool subsumes.

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 when-to-use guidance, no conditions for choosing between this tool and the three sibling security tools, and no statement of prerequisites. An agent would have to guess based on the name alone.

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

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