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

No annotations are provided, so the description carries the full burden. It does disclose one genuinely useful trait beyond the tool name: calling it with an existing name replaces rather than errors, which matters for an agent reasoning about side effects. It discloses nothing about permissions, validation, or atomicity, so the burden is only partly met.

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 short sentence with no filler and the operation verb front-loaded. The brevity is not wasteful, but it shades into under-specification: the one clause present is load-bearing while the parameter contract is left entirely unstated.

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 here, but that is the only relief. With no annotations, no parameter documentation, and a terse non-English description, an agent lacks enough to invoke this mutation correctly or predict its effect on an existing rotation of the same name.

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 both parameters are undocumented in structured data. The description only hints at the name parameter via "per nome" and says nothing about the entries array (its format, ordering, or element grammar). For a two-parameter required tool at 0% coverage, this is a significant 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?

States a verb+resource ("Aggiunge... un profilo di rotazione") and adds an upsert qualifier ("o sostituisce per nome"), so the operation is identifiable. However, it gives no differentiation from the rotation siblings (list_rotations, remove_rotation) and "profilo di rotazione" is not self-explanatory without external context. Vague-but-decodable rather than specific.

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 reference to alternatives such as list_rotations or remove_rotation. The parenthetical upsert clause implies the tool is the way to create-or-overwrite, but that is inference, not stated guidance.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states a mutation ('adds'), but reveals nothing about persistence, whether duplicates are allowed, return behavior, or whether the operation is idempotent. This is a significant gap for a write tool.

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

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

The description is a single short sentence with no waste, which is concise. However, it is under-specified rather than truly concise, and the brevity comes at the cost of useful 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 mutation tool with three undocumented parameters, no annotations, and no parameter guidance, the description is far too thin. Although an output schema exists (reducing the need to explain return values), the description does not provide the parameter semantics or behavioral context an agent needs to invoke this tool correctly.

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

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

Schema description coverage is 0%, so the schema does not document any of the three parameters. The description adds no information about 'name', 'command', or the optional 'description' field, leaving the agent to guess at formats and constraints. It fails to compensate for the coverage 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 states a clear verb ('Aggiunge' = adds) and resource ('snippet'), and 'al catalogo' scopes it. However, it does not distinguish this from siblings like list_snippets or remove_snippet beyond the obvious add/list/remove distinction, and is essentially a restatement of the tool 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, no prerequisites, and no mention of alternatives such as list_snippets or remove_snippet for managing the snippet catalog. The agent is left to infer usage from the name alone.

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

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

There are no annotations, so the description carries the full behavioral burden, and it does almost nothing here. It does not state that this executes commands on multiple hosts (a high-impact operation), what tmux vs direct mode actually changes, required auth, or expected effects. Only the multi-host scope is hinted at.

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 a single front-loaded sentence with no wasted words, which is structurally clean. However, the brevity is better described as under-specification than tight conciseness for a 4-parameter execution 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?

An output schema exists, so return values need not be explained. But for a multi-host command execution tool with no annotations, an unaddressed sibling (broadcast_wait) and a required parameter left undefined, the definition is not complete enough for confident 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% across all 4 parameters, so the description must compensate. Naming mode=tmux|direct is genuinely useful since the schema has no enum, and 'comando/snippet' maps loosely to the command/snippet parameters, but the required 'aliases' parameter and whether command/snippet are mutually exclusive are left undocumented.

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 (broadcast) and resource (comando/snippet) along with scope ('su più host') and even the mode values, so an agent can tell roughly what it does. However, it does not differentiate itself from close siblings like run_command_all, run_command_many, or broadcast_wait, which all sound like potential matches for the same task.

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 on when to choose this over run_command_all, run_command_many, or broadcast_wait, nor when to use mode=tmux versus mode=direct. The mode values are named but no selection criteria are given.

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

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

With no annotations, the description carries the full burden. It discloses that the tool waits for completion and collects output, which is useful behavioral context beyond the name. However, it omits timeout behavior, failure handling across hosts, and any safety/permission context, so important traits remain undisclosed.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately sized, though its brevity contributes to the parameter/usage gaps scored 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?

For a multi-host execution tool with zero annotation coverage and 0% schema description coverage, the description is too thin. It covers the core action and output collection, but omits parameter semantics, timeout/failure behavior, and guidance on when to use it versus similar 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 0%, yet the description does not explain any of the three parameters. 'Su più host' loosely implies the aliases target list and 'attesa' hints at timeout, but there is no explicit meaning for aliases, command, or timeout, so it barely compensates 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 states a specific verb ('Broadcast'), resource ('tmux'), scope ('su più host'), and behavior (wait for completion, collect output). It implicitly differentiates from plain 'broadcast' by adding wait/output collection, but it doesn't name alternatives or explicitly state what it is not, so 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?

No explicit when-to-use guidance or alternatives are provided. Siblings such as broadcast, run_command_all, and run_and_wait exist, but the description does not say when broadcast_wait should be chosen over them, leaving selection 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?

With no annotations, the description carries the full behavioral burden, yet it only hints that output is tail-limited. It says nothing about read-only safety, whether it reads scrollback or the visible pane, permissions, or 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?

A single short front-loaded sentence with no filler. The awkward 'ultime lines righe' mixing is a minor blemish rather than bloat.

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 described, but for a four-parameter tool with 0% schema coverage and no annotations the description is far too thin to let an agent call it correctly.

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

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

Schema coverage is 0%, so the description must compensate for four parameters and it only gestures at 'lines' via the odd phrase 'ultime lines righe'. The required 'alias' and 'session' identifiers and the optional 'window' are left unexplained in both schema and 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 states a specific verb+resource: capturing a session's output. It is clear what the tool does, but it offers no differentiation from related siblings like session_history or find_in_sessions, which an agent could confuse with it.

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 session_history, find_in_sessions, or run_command. No prerequisites or exclusions 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?

No annotations, so the description carries the full behavioral burden. It notes the session is detached (useful), but doesn't disclose what happens if the host is unreachable, whether the session persists, or auth requirements. An output schema exists, but that doesn't excuse the missing mutation 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?

A single efficient sentence that front-loads the core action and mentions the optional parameter. No wasted words.

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

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

For a mutation tool with zero annotations and 0% schema coverage, the description is too sparse. It leaves the agent guessing about parameter meanings, success behavior, and error conditions.

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

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

Schema coverage is 0% and the description only mentions the optional command parameter ('comando opzionale'). It says nothing about the required alias or the optional name, so two of three parameters are undocumented in both schema and 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?

States a specific verb (crea) and resource (sessione tmux) with the key qualifier 'detached su un host'. This distinguishes it from sibling tools like new_window or list_sessions, though it doesn't explicitly name an alternative.

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 on when to use this tool versus alternatives. The phrase 'comando opzionale' hints at the optional command param, but there's no context about prerequisites (e.g., tmux must be present) or when to prefer other tools.

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

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

No annotations are supplied, so the description carries the full behavioral burden. The qualifier 'gli altri' (the other clients) hints that the current client stays attached, which is the only behavioral detail. It discloses nothing about permissions, whether the session must exist, reversibility, or effect on the acting client.

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 short, front-loaded sentence with no filler, so nothing is wasted. But its brevity is under-specification rather than efficiency for a tool with two undocumented required parameters and no annotations.

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 session-mutating tool with no annotations and 0% schema coverage, the description is too thin. The presence of an output schema covers return values, but the missing parameter meaning, usage context, and behavioral effects leave the definition incomplete.

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% for both required parameters. The description mentions 'sessione', loosely implying the 'name' parameter, but gives no meaning for 'alias' (the host/server) and no format or constraint guidance. It fails to compensate for the documentation 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 names a specific verb ('Stacca'/detach) and resource ('client dalla sessione'), so the action is inferable. However it is written in Italian while the tool name and all siblings are English, creating friction, and it never clarifies what a 'client' is or which session/host it targets. Adequate but vague on scope.

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

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

There is no statement of when to use this tool, no prerequisites, and no alternatives among the many session-management siblings (kill_session, session_details, etc.). The agent must infer usage entirely; no exclusions or context 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, what permissions are required, whether it searches all panes or only active ones, or any side effects. Only the word 'Cerca' implies a non-mutating operation, but this is not explicit.

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 single sentence is front-loaded and contains no filler. However, for a tool with three parameters and no annotations, it is too terse to be considered appropriately sized—it omits essential context that would make the definition self-contained.

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 output schema exists, so return values need not be explained. But the description is incomplete given the tool's complexity: no parameter details, no usage guidance, and no behavioral transparency. An agent would struggle to invoke it correctly without opening the schema or guessing.

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 mentions 'regex' (pattern) and 'host' (alias), but adds no format or syntax details, and completely omits the 'lines' parameter. This leaves two parameters only vaguely addressed and one entirely undocumented.

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 ('Cerca' = search) and resource ('regex nelle pane delle sessioni tmux di un host'), clearly identifying the tool's function. It does not explicitly differentiate from siblings like capture_pane or session_history, so a 4 rather than 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?

No guidance is given on when to use this tool versus alternatives (e.g., capture_pane, session_history, or run_command). There is no mention of prerequisites, exclusions, or typical contexts, leaving the agent to infer usage entirely.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It says nothing about whether this is a read-only operation, what authentication is needed, or what kind of details are returned. The presence of an output schema reduces the need to describe return values, but safety and permissions context is absent.

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 no wasted words. It is appropriately sized for a simple tool, though it could be slightly more informative 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?

Given the tool has one required parameter, no annotations, and an output schema, the description is incomplete. It does not explain the parameter, behavior, or how it relates to sibling tools. The output schema helps with return values, but the description leaves significant gaps in understanding the tool's operation and 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?

With schema description coverage at 0%, the description does not compensate by explaining the 'alias' parameter's meaning or format. However, with only 1 parameter and an output schema present, the schema provides the structure, though the description adds no semantic value about what an alias represents.

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 'Dettagli di un host' (Details of a host) states the resource (host) and that it returns details, but it's vague about what 'details' means and does not distinguish itself from sibling tools like list_hosts or hosts_summary. It conveys the general purpose but lacks the specificity needed for confident sibling differentiation.

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 get_host versus list_hosts, hosts_summary, or ping. The description offers no context about usage conditions or alternatives.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. 'Diagnostica' implies a read-only inspection but the description doesn't confirm nature, side effects, or output shape. It lists categories (config, provider, tmux, dir log) but does not explain what is returned or any auth/rate-limit implications.

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

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

Very short but under-specified — one fragment inside parentheses listing categories rather than a full sentence. Front-loaded with 'Diagnostica' but the parenthetical adds ambiguity rather than value.

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

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

No annotations, no param schema detail, but an output schema exists so return values needn't be explained. Still, for a diagnostic tool aimed at troubleshooting, the description fails to state what the output contains, when to invoke, or how it relates to sibling 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?

Zero parameters, so by rule this dimension has a baseline of 4. No parameter semantics are needed.

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 'Diagnostica del server MCP (config, provider, tmux, dir log)' — a vague purpose statement that doesn't specify a verb or clearly define what diagnostics it returns. It distinguishes from siblings by mentioning MCP-level config/provider/tmux/log, but it remains ambiguous how it differs from other low-level tools like list_hosts or ping.

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 tool guidance provided. An agent has no way to know if this should be called prior to other operations or only during troubleshooting.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only aggregation but never states that, nor does it mention that it contacts all hosts (potentially slow), how the timeout governs the sweep, or whether results are cached or parallel.

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 short, front-loaded sentence with zero filler; 'Dashboard' leads and the three aggregated fields follow. Slightly terse given the gaps, but nothing is wasted.

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, and the description does enumerate the key aggregates. However, with no annotations and an undocumented timeout parameter, the definition leaves an agent guessing about safety profile and call mechanics.

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 single parameter 'timeout' has 0% schema description coverage and the description says nothing about it. With low coverage the description is expected to compensate by explaining units, default behavior, or per-host vs total semantics, and it does none of that.

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 composite resource: per-host reachability, tmux presence and session count, which distinguishes it from single-purpose siblings like ping_all, tmux_present or list_sessions_all. It is clear what the tool returns, though it never names those siblings to sharpen the boundary.

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. An agent cannot tell from the text whether this replaces several individual checks, when it should be preferred over ping_all plus tmux_present, or whether it fans out to every host.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states that all sessions are terminated, which signals a destructive operation, but it omits key details such as irreversibility, required permissions, error behavior, or whether the tmux server can be restarted.

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 states the action and scope immediately.

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. However, for a destructive tmux-server kill operation with no annotations and an undocumented required parameter, the description is too thin; it lacks usage guidance, parameter meaning, and behavioral warnings.

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 by explaining the single required parameter. It mentions 'un host' but never ties that to the 'alias' parameter, leaving the parameter's format and meaning entirely undocumented.

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, resource, and scope: it terminates the tmux server on a host and explicitly kills all sessions. This scope phrase distinguishes it from sibling tools like kill_session and kill_window without requiring the agent to open the schema.

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 when-to-use or when-not-to-use guidance. It implies this is a destructive broad action because it kills all sessions, but it does not name alternatives or state when an agent should choose kill_server instead of kill_session or other tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Termina' implies an irreversible destructive mutation, yet the description does not state that the session is destroyed, whether processes inside are killed, whether this requires confirmation, or any side effects. A single line is insufficient for a destructive tool with zero annotation coverage.

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 single sentence is short but under-specified rather than concise - it spends a sentence restating the tool name without conveying anything an agent could not already derive. There is no wasted padding, but there is also no useful content.

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. However, for a destructive two-parameter tool with no annotations and 0% schema description coverage, the definition is materially incomplete - nothing tells the agent how to identify the target session or what the operation destroys.

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 both required parameters (alias, name) are bare strings with no titles beyond the property names. The description adds no meaning about what alias vs. name refers to or their accepted formats, leaving the agent to guess the host/session addressing scheme.

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+resource (terminating a tmux session), which cleanly separates it from siblings like kill_server, kill_window, and detach_clients. It is clear what the tool operates on, though it does not explicitly contrast itself with those adjacent teardown tools.

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 mention of prerequisites, and no pointer to alternatives such as kill_server for server-wide teardown. The agent must infer context entirely 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?

No annotations are provided, so the description carries the full disclosure burden. "Chiude" implies a destructive mutation, yet nothing is said about irreversibility, required permissions, effects on the parent session, or whether other windows are affected.

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 a single short sentence with no wasted words, but this is under-specification rather than effective conciseness. Brevity here removes required information rather than compressing it.

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?

Even though an output schema exists and return values need no explanation, a destructive three-parameter tool with zero annotation and zero schema coverage needs far more than four words. Nothing about identity of the target window, safety, or consequences is conveyed.

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

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

All three parameters (alias, session, window_id) have 0% schema description coverage and the description adds no meaning for any of them. It does not clarify how window_id is obtained, whether session scopes the lookup, or what alias identifies.

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?

"Chiude una finestra" states a verb and resource, so the general action (close a window) is clear. However, it gives no scope, no identification of which window, and nothing that distinguishes it from siblings such as kill_session, kill_server, or new_window/rename_window, leaving the agent to infer fit.

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 kill_session or kill_server, no prerequisites, and no mention of what happens to the session afterward. The description offers nothing an agent can act on for routing decisions.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one trait (the logs are compressed) but says nothing about read-only nature, permissions, or ordering; an output schema exists so return format is partially covered, but the safety/behavior profile is essentially undeclared.

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, front-loaded sentence with no filler. It is efficient, though the extreme terseness borders on under-specification rather than optimal 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?

For a parameterless list tool with an output schema, the essentials are present. However, the crowded audit-log sibling set (list_remote_audit_logs, read_audit_log, read_remote_audit_log) makes the absence of any routing guidance a real 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?

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to document beyond what the empty schema already conveys.

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 ("Elenca") and a scoped resource ("log audit compressi locali"). The qualifier "locali" implicitly separates it from list_remote_audit_logs, and "Elenca" (list) distinguishes it from read_audit_log. The purpose is clear though the differentiation is by adjective rather than explicit statement.

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 or when-not-to-use guidance is given. The agent must infer from the single word "locali" that this is the local counterpart to list_remote_audit_logs; nothing names an alternative or a selecting condition.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it says nothing about being read-only, pagination, ordering, or whether it includes offline/unreachable hosts. It only restates the listing action.

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 short sentence with zero filler, and the purpose is front-loaded. It is efficient, though arguably under-specified rather than optimized.

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 is trivial (no parameters) and an output schema exists, so return values need not be explained. Still, the absence of any read-only/safety context or sibling differentiation leaves a small but real gap for an unannotated tool.

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

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

The tool takes zero parameters, which is the baseline-4 case, and the description introduces no parameter semantics that could conflict with the empty schema. There is nothing further for the description to clarify 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?

The description gives a specific verb and resource ("Elenca gli host configurati") so an agent knows it returns the list of configured hosts. It is clear on its own, but it does not distinguish itself from the closely related sibling get_host or hosts_summary, so an agent must infer the difference.

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 exclusions, and no mention of alternatives such as get_host (single host) or hosts_summary (aggregate view), despite those siblings existing. The agent is left to infer routing from the name alone.

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

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

With no annotations, the description carries the full behavioral burden. It does add one useful trait — the logs are compressed — but says nothing about required permissions, whether the host must be connected, pagination/limits, or failure behavior. For a remote-access tool with zero annotation coverage this is a notable 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?

A single short sentence with no filler, front-loaded with the verb and resource. It is concise, but brevity here shades into under-specification rather than demonstrating efficient information packing.

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 described, and this is a simple list operation over one parameter. Still, the undocumented 'alias' parameter and the absence of any connectivity/permission context leave the definition only minimally adequate for a remote-host tool.

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

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

The schema has 0% description coverage and the description never explains the single 'alias' parameter, leaving the agent to guess it refers to a configured host alias. A one-param tool with no param documentation anywhere is a real gap, though the semantics are at least inferable from the sibling list_hosts/get_host family.

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 ('Elenca i log audit compressi') scoped to the remote host, which distinguishes it from the local sibling list_audit_logs and from read_remote_audit_log. It is clear what the tool does, though it never names those siblings explicitly to reinforce the distinction.

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 statement of when to use this versus list_audit_logs or read_remote_audit_log, and no prerequisites (e.g. that the host must be reachable or that an alias must already exist). The agent must infer routing from the tool 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?

No annotations are provided, so the description carries the full disclosure burden, and it only restates that profiles are listed. It says nothing about ordering, scope (per-host vs global), whether authentication or an active session is required, or that the operation is non-destructive — all inferable only from the verb 'Elenca'.

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 short sentence with no filler, and the verb-resource pair is front-loaded. It is arguably too terse for a tool with no annotation coverage, but there is no wasted text.

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

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

With zero parameters and an output schema present, the return values need no explanation, so the minimum bar is low and the sentence clears it. However, with no annotations and no sibling routing, the definition is only barely sufficient for an agent choosing between this and the other rotation 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?

The tool takes zero parameters, so there is no parameter semantics for the description to add; the baseline for a no-arg tool applies. Nothing here misleads about inputs.

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 pairs a specific verb ('Elenca') with a specific resource ('profili di rotazione salvati'), so the agent can tell it enumerates saved rotation profiles. It does not, however, distinguish itself from the closely related add_rotation/remove_rotation siblings or flag the read-only scope relative to 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 when-to-use guidance and no mention of alternatives such as add_rotation or remove_rotation, which sit directly next to this tool in the sibling list. The agent must infer from the name alone that this is the read counterpart to those mutation tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Elenca' implies a read-only listing, but the description says nothing about permissions, behavior when the host is unreachable or tmux is absent, or whether results are paginated.

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 short sentence with no filler, front-loading the verb and resource. It is efficient, though its brevity is partly a symptom of under-specification rather than deliberate tightness.

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 tool in a large sibling set, the description omits the host-alias semantics, failure modes, and the distinction from list_sessions_all that an agent needs to choose correctly.

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

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

The single required parameter 'alias' has 0% schema description coverage, and the description only obliquely implies it identifies the host ('di un host'). It does not state the expected alias format or where aliases come from (e.g., list_hosts).

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 ('Elenca le sessioni tmux di un host'), which is clearer than a tautology. However, it does not distinguish itself from the closely named sibling list_sessions_all, leaving the agent to infer the difference.

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 mention of prerequisites such as the host needing to be reachable or tmux present, and no reference to alternatives like list_sessions_all or session_details.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses parallel fan-out execution, which is useful, but says nothing about partial failure handling (unreachable hosts), timeout behavior, or result ordering — all material for an all-hosts aggregator.

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, front-loaded sentence with no filler. It is appropriately sized for a no-argument list tool, though it is terse enough that a touch more context could have been added without bloat.

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, and there are no parameters to document. What is missing is behavioral completeness for a multi-host fan-out (failure/timeout semantics) given the absence of any 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. Schema coverage of 100% confirms no hidden inputs.

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 ("Elenca") and resource ("sessioni tmux") and adds the scope "di tutti gli host", which cleanly distinguishes it from the sibling list_sessions (single host). It does not name that sibling explicitly, so it stops just 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?

The "tutti gli host" scope implies when to reach for this over list_sessions, and "in parallelo" suggests it is a fan-out aggregate call. However, there is no explicit when-to-use/when-not guidance or named alternative, leaving the routing to the agent's 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?

No annotations provided, so the description carries full behavioral burden. It implies a read operation but does not confirm read-only safety, mention pagination, or describe what the return set looks like. For a 0-param list tool with no annotations, this is thin.

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 short sentence that is front-loaded and wastes no words. However, it is arguably too terse given the lack of other descriptive context.

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 with no annotations and no usage context, the description is barely adequate. It tells the agent what the tool does but not when to use it, what the catalog scope is, or any constraints.

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?

Zero parameters required, so baseline is 4. The description does not need to explain parameter behavior, and schema coverage is 100% (empty object).

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 clear verb+resource: lists snippets from the catalog. Distinguishable from siblings like add_snippet and remove_snippet since it is a read-only list operation. However, it does not clarify scope (all snippets vs. filtered) or differentiate from other list_* tools beyond naming the resource.

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

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

No guidance on when to use this versus alternatives. The agent gets no context on prerequisites, whether it's scoped to a session or global, or what to do if no snippets exist. Implicit usage only.

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

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

No annotations are provided, so the description carries the full burden. The verb 'Elenca' clearly signals a read-only listing operation, but it does not disclose authentication needs, rate limits, or whether the host must be reachable.

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. Every word contributes to the purpose.

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

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

An output schema exists, so return values need not be described. However, against a sibling list_tunnels_all and other tunnel tools, the description omits routing guidance and any behavioral caveats, leaving it adequate but incomplete.

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 single parameter 'alias' has no schema-level explanation. The phrase 'di un host' usefully clarifies that alias identifies a host, but it provides no format or validation 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 states a specific verb ('Elenca') and resource ('tunnel') and scopes it to a single host, which distinguishes it from the likely all-hosts sibling list_tunnels_all. It does not explicitly name or contrast with that sibling, so 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 guidance on when to use this tool versus list_tunnels_all or other tunnel-related siblings like tunnel_health. Usage is only implied by the purpose statement.

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

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

With no annotations, the description must carry the behavioral burden, and "Elenca" does imply a read-only enumeration across all hosts, which is useful. It does not state cost, latency, or whether unreachable hosts are skipped, which matters for a fan-out across all hosts. The existence of an output schema means return-value detail is not required here.

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 compact sentence with the scope front-loaded and zero padding. It is arguably under-specified rather than over-long, so conciseness itself is not the 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?

For a parameterless, read-only listing with an output schema, the description covers what is enumerated and over what scope, which is most of what an agent needs. The remaining gap is routing among the several tunnel-related siblings, which is only weakly addressed.

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 takes zero parameters, so the baseline is 4 and there is nothing for the description to clarify. No misleading parameter hints are present.

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 ("Elenca") and resource ("tunnel") plus scope ("su tutti gli host"), which implicitly separates it from the sibling list_tunnels. It adds that active state is included, so the returned content is partly described. It is not an exact restatement of the name, but the very short phrasing leaves the sibling distinction inferential rather than explicit.

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

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

There is no statement of when to use this versus list_tunnels, tunnel_health, or stop_tunnels. The "all hosts" scope is the only usage signal, and it is incidental rather than framed as guidance. No prerequisites or exclusions are given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says only that it lists windows and does not state that the operation is read-only, whether it requires permissions, pagination behavior, or any other context beyond the basic purpose.

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 or repetition. While it is very terse, its shortness reflects missing content rather than poor conciseness or structure.

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 need not be described, the tool has two required parameters with no schema descriptions and no annotations. The description does not explain alias/session usage or distinguish this tool from many related tmux siblings, leaving the agent with significant gaps for correct selection and invocation.

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

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

Schema description coverage is 0% for two required parameters. The description indirectly references the session parameter ('di una sessione') but says nothing about the alias parameter, its meaning, or expected format, so it fails to compensate for the undocumented schema.

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

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

The description states a specific verb ('Elenca') and resource ('finestre') scoped to a session, making it distinguishable from sibling list tools like list_sessions or list_hosts. It does not, however, name the alternative window-specific tools (new_window, kill_window) or otherwise differentiate from 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 list_sessions or session_details, nor any prerequisites or exclusions. Usage is only implied by the tool name and the phrase 'di una sessione'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Crea' implies a mutation against an existing session, but there is no mention of permissions, failure modes, what happens to the new window's state, or default naming. The behavioral picture is essentially blank.

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 single short sentence is not wasteful per se, but it is under-specified rather than concise, carrying no useful information beyond the tool name. Brevity here reflects omission, not 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?

An output schema exists, so return values need not be explained. Still, for a mutation tool with zero annotation coverage and three undocumented parameters, the description leaves the agent without prerequisites, parameter intent, or sibling routing. It is inadequate for the complexity of the operation.

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% across three parameters (name, alias, session), and the description supplies no meaning for any of them. In particular the distinction between 'alias' and 'name'—and their required/optional status—is left entirely undocumented. With low coverage the description was obliged to compensate and does not.

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 ('Crea una finestra') and scopes it to a session, so the basic action is inferable. However, it is little more than a restatement of the tool name and gives no differentiation from siblings such as create_session or list_windows. Purpose is vague enough that an agent must rely on the name alone to disambiguate.

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, prerequisites, or alternatives are given. The description does not tell the agent whether a session must already exist, nor route it toward create_session versus this tool. Usage is only implied by 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?

With no annotations, the description carries the full behavioral burden and mostly fails to. It does not state whether the probe is read-only/safe, how the timeout behaves, whether failures are returned as errors or results, or any rate/permission constraints.

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 front-loaded sentence with zero filler or redundancy. It is efficient, though its brevity borders on under-specification rather than deliberate 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?

The presence of an output schema means return values need not be described, but for a network-probe tool with two undocumented parameters and no annotations, the description is too thin to convey operational 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 0%, so the description must compensate and does not: it never explains what 'alias' refers to or what 'timeout' controls. Only the word 'host' loosely hints that alias is a host reference.

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: it verifies TCP reachability of a host. This is clear and distinguishable from ping_all via the singular 'un host', though it does not explicitly name or contrast that sibling.

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

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

There is no explicit when-to-use guidance, no mention of prerequisites, and no reference to alternatives such as ping_all. The only hint is the singular 'host', which implicitly suggests single-target use, but this is left entirely 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?

With no annotations, the description carries the full behavioral burden, yet it only discloses that the ping is TCP-based (vs ICMP). It says nothing about whether hosts are probed in parallel or sequentially, how failures/timeouts are reported, or whether this can be slow with many hosts — all material for a fan-out operation.

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

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

A single short sentence with no filler and the resource scope front-loaded. It is efficient, though arguably under-specified rather than genuinely tight.

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 definition still omits timeout units, fan-out behavior, and any usage context. For a bulk network operation with zero annotation coverage and zero parameter documentation, this is too thin.

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?

One parameter with 0% schema description coverage: 'timeout' has no description, and the description never explains its unit (seconds?) or whether it applies per host or to the whole sweep. The schema default of 2 is the only semantic hint available.

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 concrete verb and resource ('Ping TCP di tutti gli host'), and the 'all hosts' scope implicitly separates it from the sibling 'ping' (single host). It stops short of an explicit sibling contrast, and the Italian phrasing is the only wording available, but an agent can tell what it 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?

No indication of when to use this versus 'ping', 'list_hosts', or other host tools, and no prerequisites or exclusions. The agent must infer that 'ping_all' is the bulk variant of 'ping' from the name alone.

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

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

No annotations are provided, so the description carries the full burden, and it only discloses that the file is local and .gz and that max_lines=0 means everything. It says nothing about permissions, expected file size/cost, error behavior on missing files, or output shape beyond the schema.

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

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

A single compact sentence with no filler, and the core semantics (local .gz log / max_lines=0) are front-loaded. Nothing is wasted, though it is arguably too short for the parameter burden.

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, and the max_lines convention is covered. Still, for a file-reading tool with zero annotation and zero schema-description coverage, the filename semantics and read caveats 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 coverage is 0%, so the description must compensate; it does explain the non-obvious max_lines=0 sentinel, which is the key semantic. The required 'filename' parameter is left undocumented (path base, relative vs absolute, .gz requirement).

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 plus resource ('Legge un log audit .gz locale') and the 'locale' qualifier implicitly distinguishes it from read_remote_audit_log. It is clear enough that an agent can pick this over the remote variant, but it does not name the alternative explicitly.

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 word 'locale' implies this is the counterpart to remote log reading, so the choice context is inferable, but there is no explicit when-to-use or when-not wording and no 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?

No annotations are provided, so the description must carry behavioral disclosure. It says the log is remote and .gz and explains max_lines=0, but omits authentication needs, error behavior, decompression handling, and other operational context for a remote file read.

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

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

A single, front-loaded sentence with no filler. It states the action, the remote/.gz aspect, and the max_lines=0 convention without unnecessary words.

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

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

The output schema means return values need not be explained, but with no annotations and 0% schema coverage the description is too thin for a 3-parameter remote file reader. Required parameters and remote access behavior remain undocumented.

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 only partially explains max_lines=0. It does not explain the required alias or filename parameters, such as what an alias refers to or whether filename must be a .gz path.

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: reads a remote .gz audit log. The word 'remote' helps distinguish it from read_audit_log and list_remote_audit_logs, but no sibling is named explicitly, so it falls short of a full 5.

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

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

There is no guidance on when to use this tool versus read_audit_log, list_remote_audit_logs, or list_audit_logs. The only usage hint is the max_lines=0 convention, which is parameter behavior rather than selection guidance.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether this is destructive/irreversible, what happens if the named profile does not exist, whether it affects running tunnels, or any permission requirements. For a removal (mutation) tool, this is a significant 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?

A single short sentence that is front-loaded and contains no wasted words. It is appropriately sized for a simple tool, though it carries almost no information beyond the name.

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. However, for a destructive removal tool with no annotations and 0% parameter description coverage, the description is too sparse: it doesn't cover side effects, error behavior, or parameter sourcing. It is minimally viable but has clear gaps.

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 there is 1 required parameter ('name'). The description only implies an identifier is needed via the resource name but adds no semantics about the format, source, or constraints of 'name'. This is the baseline 3 for a single-parameter tool where the schema provides the name but no 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?

States a specific verb+resource: 'Rimuove un profilo di rotazione' (Removes a rotation profile). Clearly distinguishable from sibling add_rotation and list_rotations. However, the description is in Italian while all sibling tools and schema titles are in English, creating a language mismatch that slightly reduces clarity for an English-context agent.

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

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

Implies usage (use this to remove an existing rotation profile) and the sibling set (add_rotation, list_rotations) makes the alternative obvious, but there is no explicit when-to-use or when-not-to-use guidance, no mention of prerequisites, and no mention of alternatives.

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

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

...

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?

...

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?

...

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?

...

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?

...

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?

...

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only asserts that a rename happens. It does not state whether the target session must exist, whether names must be unique, or what happens on failure. Only the mutation intent is conveyed.

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 a single short sentence, but the brevity reflects under-specification rather than efficient front-loading. There is nothing to structure.

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 described, but for a three-parameter mutation tool with no annotations and no parameter documentation, the description leaves an agent unable to call it 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 0% for three required parameters (alias, old_name, new_name), and the description adds no meaning for any of them — notably the 'alias' parameter, whose purpose (target host?) is entirely unexplained.

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 ('Rinomina una sessione tmux'), so the core action is clear. However, it does nothing to distinguish itself from the sibling 'rename_window', which follows the identical pattern, nor does it clarify the session-selection scope.

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

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

No guidance on when to use this versus alternatives such as create_session, kill_session, or rename_window. The agent must infer usage entirely 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?

With no annotations provided, the description carries the full behavioral burden, yet it discloses nothing: not that it mutates state, not that it requires a valid session/alias/window_id, not whether the old name is discarded or anything about error/failure 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 a single short sentence with no wasted words, but it is under-specified rather than concise — brevity here comes from omission of all 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?

For a four-parameter mutation tool with no annotations, this is completely inadequate. The output schema exists, so return values need not be described, but nothing about the operation itself is conveyed.

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 four required parameters (alias, session, window_id, new_name) are entirely undocumented; the description does not compensate in any way.

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 phrase 'Rinomina una finestra' is a tautological restatement of the tool name rename_window; it adds no scope, no target enumeration, and does not distinguish this from the sibling rename_session.

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 indication of when to use this tool versus alternatives such as rename_session, nor any prerequisite about needing an existing window or active session.

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

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

With no annotations, the description carries full burden, and it does disclose two real behaviors: detached execution and a sentinel-based blocking wait. However it omits what happens on timeout, failure modes, auth/permission requirements, and whether output is streamed or only retrieved afterward.

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 front-loaded sentence with zero filler; the key action and the waiting behavior come first. Nothing here is padding.

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 for a command-execution tool with no annotations and 0% parameter coverage the definition is too thin: targeting ('alias') and timeout semantics are never addressed.

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% across three parameters. The description only indirectly implies the 'command' parameter and says nothing about 'alias' (which host/session to target) or 'timeout', so it fails to compensate for the undocumented schema.

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

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

The description states a specific verb and resource ('esegue un comando in tmux'), plus a distinctive behavior ('detached' and 'attende il completamento'). It is clearly distinguishable in spirit from siblings like run_command, though it never names an alternative explicitly, which keeps it 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 implies you use this when you need to block on completion ('attende il completamento'), but gives no explicit when-to-use guidance and never contrasts with run_command, run_command_many, or broadcast_wait. An agent must infer the routing decision from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It mentions ssh execution and 'batch' but does not disclose critical behavior: whether it blocks until completion, how output is returned, what happens on timeout, or that it likely requires authentication to the host. The 'batch' wording is ambiguous, and the timeout parameter's default of 60 seconds is documented in the schema, but the description does not explain its effect. This is insufficient for a command-execution tool.

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

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

The description is a single, front-loaded sentence with no filler or repetition. It is very concise, though that conciseness comes at the cost of missing critical details. For its length, the structure is acceptable.

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. However, for a command-execution tool with no annotations, zero parameter descriptions, and multiple similar siblings, the description is far too sparse. It does not cover prerequisites (ssh auth), execution semantics, or the distinction from sibling tools, leaving the agent under-informed.

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 schema provides bare titles with no descriptions. The description does not explain what 'alias' refers to (presumably a host alias from list_hosts, but this is not stated), what format 'command' expects, or how 'timeout' behaves. With three undocumented parameters, the description fails to compensate for the coverage 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 states a verb (Esegue) and resource (comando batch) on an ssh host, which is understandable. However, it does not differentiate from sibling tools like run_command_all, run_command_many, or run_and_wait, which appear to execute commands in different scopes or modes. Without that differentiation, an agent cannot confidently choose this tool over its 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 use this tool versus run_command_all, run_command_many, run_and_wait, or send_keys. The description only states what it does, not the context that selects it. For a command-execution tool in a crowded toolset, this is a notable 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?

No annotations are provided, so the description carries the full behavioral burden. It implicitly discloses that unreachable hosts are skipped ('raggiungibili'), a useful detail, but says nothing about destructive potential, required permissions, failure handling across hosts, or what the timeout bounds.

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 front-loaded sentence with no waste, but also no depth; the brevity reflects under-specification rather than disciplined concision. The Italian text is also inconsistent with the English tool name and sibling names.

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 for a high-blast-radius tool that executes commands across every reachable host with no annotations and zero parameter documentation, the description leaves critical 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% for both parameters. The description references running a command but gives no syntax, format, or shell-context details for 'command', and never mentions 'timeout' or its default of 60 seconds. It does not compensate for the coverage 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?

States a specific verb (esegue) with a scope (un comando batch su tutti gli host raggiungibili), which separates it from the single-host run_command sibling. However, it never names run_command_many or broadcast as alternatives, so discrimination relies on inference from the scope phrase 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?

No when-to-use guidance is given. With siblings like run_command, run_command_many, and broadcast in the same family, the agent gets no explicit criteria for choosing this tool over them.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that execution is parallel across hosts; it says nothing about failure handling on partial hosts, timeout semantics, permission/auth requirements, or the destructive potential of arbitrary commands.

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, front-loaded sentence with no waste. It is efficient, though arguably too sparse for a tool with four undocumented parameters.

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

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

An output schema exists so return values need no explanation, but for an execution tool with zero annotation coverage and 0% parameter documentation, the description leaves major gaps about targets, timeout, and concurrency 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 0% with four parameters, so the description must compensate and does not. 'aliases' (target hosts), 'timeout', and 'max_workers' are never explained; 'batch' versus a singular 'command' string is left unclear.

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 ('Esegue un comando batch in parallelo su più host'), so the agent knows it runs commands across hosts concurrently. It does not, however, distinguish itself from the very similar sibling run_command_all, leaving the multi-host overlap ambiguous.

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

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

No guidance on when to choose this over run_command, run_command_all, run_and_wait, or broadcast. The parallel/scope condition is implied but never tied to an explicit alternative, so the agent must infer routing from the name alone.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it supplies almost none. It does not say whether it sends a literal Enter keystroke versus a newline, whether it focuses the target window, what permissions are needed, or any error/retry behavior. Only the destination ('alla sessione') is conveyed.

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 single sentence is short but under-specified rather than concise; it wastes the one sentence it has on restating the name instead of conveying actionable detail. There is nothing to front-load because no substantive content is present.

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

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

An output schema exists, so return values need not be explained, but for a keystroke-injection tool with no annotations and fully undocumented parameters, the description is far too thin. It omits prerequisites, behavior, and parameter meaning that an agent would need to call it correctly.

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

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

Schema description coverage is 0% for two required parameters, so the description must compensate, but it only obliquely references the 'session' parameter and says nothing about 'alias'. The distinction between alias and session — both required strings — is left completely undefined.

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 'Invia Invio alla sessione' is essentially the tool name (send_enter) restated verbatim in another language, so it adds no new information beyond the identifier. It also fails to distinguish itself from close siblings like send_keys, send_raw, and run_command, leaving the agent unable to tell which keystroke tool applies.

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 send_keys, send_raw, or run_command, nor any stated prerequisites such as an active session or alias. The agent is left to infer usage entirely 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?

With no annotations, the description carries the full behavioral burden, and it only discloses that the text is sent literally (i.e. escape/key sequences are not interpreted). It does not say whether a newline/Enter is appended, whether the session must exist or be attached, or what happens on a missing session.

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 front-loaded sentence with no filler, which is appropriately sized for a short tool. Its terseness is a completeness problem rather than a conciseness one.

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 for a 3-parameter mutation tool with zero annotation and zero schema-description coverage, the definition is far too thin: no alias meaning, no newline behavior, no prerequisites.

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% for all three required params. The description clarifies the 'text' parameter as literal text and implies 'session', but 'alias' (which host/server the session lives on) is entirely undocumented in both schema and 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 states a concrete verb (sends) and resource (literal text to the session), and the word 'literal' implicitly contrasts with less literal siblings like send_raw or send_enter. However, it never names those siblings, so an agent must infer the distinction from the whole toolset.

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 rather than send_raw, send_enter, run_command, or broadcast, nor any stated prerequisites (e.g. an attached/existing session). The agent is left to guess from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only states that non-literal keys are sent and gives examples, without disclosing side effects, session targeting behavior, authentication needs, or reversibility.

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 front-loaded sentence with no filler; the example parenthetical earns its place by clarifying the key format. It is concise, though the overall definition remains sparse for the tool's complexity.

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

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

With no annotations, 0% schema description coverage, and three required parameters, the description is too thin. The output schema relieves it of explaining return values, but it still omits parameter meaning and sibling-tool guidance.

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% across three required parameters. The description adds meaning for 'keys' via examples like C-c and Up, but says nothing about how 'alias' or 'session' should be supplied or what they refer to.

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 ('Invia tasti tmux') and scopes it to non-literal keys with examples. This helps distinguish it from literal key sending siblings, but it does not explicitly name or contrast with alternatives like send_keys.

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 phrase 'non letterali' implies the tool is for special/raw tmux key sequences, but there is no explicit when-to-use guidance, prerequisites, or comparison to sibling tools such as send_keys or send_enter.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it discloses almost nothing. It does not confirm this is a read-only lookup, whether both alias and name must resolve to an existing session, or what happens on a missing session.

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 five-word sentence is not wasteful, but it is under-specified rather than concise; there is no front-loaded distinction, scope, or outcome for the agent to act on.

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 with zero schema coverage for two required parameters and no annotations, the definition leaves an agent guessing about addressing (alias vs name) and behavior. It is inadequate for a parameterized tool.

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

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

Schema description coverage is 0% for both required parameters. The description mentions only 'sessione', loosely hinting at the name parameter, and says nothing about the alias parameter or the host/session addressing model, so it does not compensate for the undocumented 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-less noun phrase 'Dettagli di una sessione tmux' identifies the resource (a tmux session) and implies a read of its details, but 'details' is vague about what is returned or filtered. It does not distinguish itself from siblings like get_status, list_sessions, or session_history, which an agent would also consider for session information.

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 tool versus alternatives such as session_history or get_status, and no prerequisites are mentioned. The agent must infer usage entirely 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?

With no annotations, the description carries the full behavioral burden. It does disclose the data source (history.json), which weakly signals a local, read-only retrospective lookup, but it says nothing about retention scope, ordering, or whether the file must exist. For a no-annotation tool this is thin.

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 short sentence with no filler, and the key concept (recent session chronology) is front-loaded. It is terse but not padded, which is appropriate for a zero-parameter read.

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 no explanation, and there are no parameters to document. The remaining gap is the missing distinction from the many sibling listing tools, which the description should have addressed given the crowded namespace.

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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. No misleading parameter hints are present.

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 the resource ('sessioni recenti') and the underlying data source ('history.json'), giving a real sense of what the tool returns. However, it is a bare noun phrase with no verb and does not differentiate itself from close siblings like list_sessions, list_sessions_all, or find_in_sessions, so an agent must guess how 'history' differs from a plain session listing.

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

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

No when-to-use guidance is given, and no alternatives are named despite several sibling tools covering session listings and searches. The agent is left to infer that this is the historical/past-sessions view on its own.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says only that a tunnel is started, with no disclosure of authentication requirements, side effects (e.g., port binding, persistence), error conditions, or whether the operation is reversible. This is essentially no behavioral context beyond the name.

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 single-sentence fragment is short but under-specified rather than truly concise. It front-loads the main action, but omits all essential details about parameters and behavior that an agent would need, so the brevity comes at the cost of utility.

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 7 parameters, 3 required, zero schema descriptions, no annotations, and 42 sibling tools, the description is drastically incomplete. While an output schema exists and return values need not be explained, the description does not provide enough context for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0% across 7 parameters. The description adds meaning only for "kind" by listing L/R/D, but leaves alias, local_port, remote_host, remote_port, bind, and name completely undocumented. This partial hint does not compensate for the severe coverage 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 states a specific verb ("Avvia") and resource ("tunnel SSH"), and hints at the kind variants (L/R/D). It clearly differentiates from siblings like stop_tunnel or list_tunnels by the action itself, though it does not explicitly name any alternative or scope details.

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, no prerequisites (e.g., SSH alias must exist), and no mention of alternatives like stop_tunnel or tunnel_health. The description merely says what it does, not when or why to call it.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Ferma' implies cancellation of a running process (non-read-only, potentially destructive to the tunnel process), but the description doesn't say whether the tunnel is terminated, whether it can be restarted, what errors occur if the tunnel doesn't exist, or what auth is required. It only adds that termination is scoped to a local port.

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 waste, but it is under-specified rather than concise. Brevity here comes at the cost of clarity.

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

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

An output schema exists, which reduces the need to explain return values, but the description still lacks usage context, parameter meanings, and the behavioral implications of stopping a tunnel. For a mutation-style operation with no annotations, more detail is needed to let an agent call it correctly.

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

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

Schema description coverage is 0% and neither required parameter (alias, local_port) is explained in the description. The word 'porta' vaguely gestures at local_port, but alias is completely undocumented, and a 2-param tool with 0% coverage should get explanatory value from the description, which it doesn't.

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 'Ferma il tunnel su una porta' (Stop the tunnel on a port), which gives a verb (Ferma/Stop) and a resource (tunnel), but it's vague about scope and doesn't differentiate clearly from siblings like stop_tunnels (plural). The Italian phrasing also doesn't match the English tool name style, which could confuse an agent about whether it's the same 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 guidance about when to use this tool versus alternatives. The sibling list contains stop_tunnels, list_tunnels, start_tunnel, tunnel_health, and list_tunnels_all, but the description never mentions any of them or any conditions for selection.

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

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

With no annotations provided, the description carries the full behavioral burden but discloses only that all tunnels are stopped. It does not say whether the operation is destructive, whether it requires privileges, what happens to existing connections, or whether it can be undone.

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 wasted words and the operation is front-loaded. It is appropriately sized for a simple tool, though it sacrifices completeness for brevity.

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 mutation-like tool with no annotations, one undocumented parameter, and an output schema, the description is still too sparse. It omits parameter semantics, safety behavior, and any usage context needed to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must clarify the single 'alias' parameter. It implies a host is targeted, but never names or explains the alias format, expected values, or relationship to the host.

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 ('Ferma' / stop) and resource ('tunnel') with scope ('tutti' / all) and target ('di un host' / of a host). It distinguishes itself from the singular sibling stop_tunnel by specifying all tunnels, though it does not name the sibling explicitly.

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 alternatives such as stop_tunnel, kill_session, or list_tunnels. The description only restates the operation without context, preconditions, or 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?

With no annotations at all, the description carries the full burden. It discloses only the boolean outcome (tmux present or not), but says nothing about permissions, timeout/error behavior when the host is unreachable, or whether it performs any remote command 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?

One short, front-loaded sentence with no filler or redundancy. It is efficient, though the brevity borders on under-specification rather than true 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 the return value need not be explained. However, for a tool with a required but undocumented parameter and no annotations, the description omits the host-targeting semantics and call preconditions that an agent needs.

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 single required parameter 'alias' has 0% schema description coverage and is never mentioned in the description. Nothing explains that the alias identifies the target host, which is essential for calling the tool 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 names a specific predicate and resource ('True if tmux is installed on the host'), which is clear enough to distinguish a presence check from sibling action tools like run_command or create_session. It does not, however, explicitly differentiate itself from other diagnostic siblings such as ping or get_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?

There is no guidance on when to call this probe versus alternatives like ping, get_host, or get_status, nor any stated preconditions. The agent is left to infer the use case entirely.

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

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

No annotations are provided, so the description carries the full burden. 'Verifica' implies a read-only diagnostic and 'tunnel attivi' narrows the scope to active tunnels, but there is no statement about side effects, permission requirements, or whether it probes the network (with possible latency/failure 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?

One sentence, front-loaded with the verb and scope, with zero filler. Appropriately sized for a single-parameter diagnostic 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?

An output schema exists, so return values need not be explained, and the check's subject is clear. However, the undocumented parameter and absent when-to-use guidance leave the definition only minimally complete for correct invocation.

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

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

Schema description coverage is 0% and the description never mentions the single 'alias' parameter or what value it expects (a tunnel alias, a host alias?). With low coverage the description should compensate, and it does not.

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+resource: verifying that the local ports of active tunnels are actually listening. This distinguishes it clearly from list_tunnels/start_tunnel, though it never names those siblings or explicitly contrasts 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?

No guidance on when to reach for this versus list_tunnels or get_status, no prerequisites, and no note about whether it applies only to tunnels started in this session. The agent must infer usage entirely from the one-line purpose.

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