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 discloses two important behaviors: automatic file vs directory detection and recursive directory downloads. However, it does not mention overwrite behavior, local directory creation, or failure semantics, which would add useful context for a file-writing 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?

Three short sentences with no filler. The primary purpose is front-loaded, followed by the two key behavioral details. Every sentence contributes 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 simple download tool with fully documented parameters and no output schema, the description covers purpose, direction, and the key recursive directory behavior. It is slightly light on overwrite/error expectations, but an agent has enough context to select and 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 100%, with all three parameters already documented as absolute paths or the connection ID. The description adds file/directory behavior and recursion context, but does not need to repeat parameter definitions since the schema already covers them.

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 ('Download'), resource ('remote file or directory'), target ('local machine'), and transport ('SFTP'). The automatic file-vs-directory detection and recursive directory behavior clearly distinguish it from siblings like sftp_read, sftp_list, and sftp_upload.

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 directionality ('remote... to local machine') makes the intended use obvious relative to upload/read/list operations. It does not explicitly name alternatives or exclusion conditions, but the use case is clear enough for an agent to decide when to invoke it.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It reveals the basic listing action but does not mention return format, whether the listing is recursive, whether an active connection is required, or how errors from invalid paths are handled.

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 with no redundant phrasing. The core action and protocol are front-loaded and every word adds informational 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?

For a simple two-parameter read-only tool, the description is adequate, but gaps remain: there is no output schema and no mention of what the listing returns, prerequisites, or behavior on inaccessible paths. It is minimum viable but not fully complete.

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

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

Schema description coverage is 100%, and both remotePath and connectionId have concise descriptions. The tool description adds no parameter nuance, so the schema carries the weight; a baseline of 3 is appropriate.

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

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

The description uses a specific verb ('List') and a clear resource ('files and directories in a remote path via SFTP'), which is unambiguous. It does not explicitly contrast itself with siblings like sftp_read or sftp_upload, 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 guidance is given about when to choose sftp_list instead of sftp_read, sftp_upload, or ssh_exec. The description only restates what the tool does; it does not explain context, prerequisites, 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, the description carries the full burden of behavioral disclosure, but it mostly restates the read operation. It does not state that the remote file is unmodified, how the contents are returned, whether binary files are supported, or what errors might occur.

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 14-word sentence with no filler; the core verb and object are front-loaded. It is appropriately short, even though this brevity comes at the cost of missing behavioral 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?

For a two-parameter tool the invocation shape is simple, but there is no output schema and the description never explicitly states the return value format or how this tool differs from sftp_download. Given the sibling ambiguity and lack of annotations, the description is not complete enough for confident tool selection.

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

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

Schema description coverage is 100%, with clear descriptions for remotePath ('Absolute path to the remote file') and connectionId ('The connection ID'), so the schema documents both parameters. The tool description itself adds no parameter-level meaning beyond 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 uses the specific verb 'Read' and the resource 'contents of a file on a connected remote host via SFTP', so the core operation is clear. However, it does not distinguish this from sibling sftp_download, which could also handle file-retrieval requests.

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 about when to choose sftp_read over siblings such as sftp_download or sftp_list. The phrase 'connected remote host' implies an existing connection, but there are no prerequisites, exclusions, or alternative routing instructions.

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 responsibility for behavioral disclosure. It usefully reveals auto-detection of files vs directories and recursive directory uploads, but it does not mention overwrite behavior, permission requirements, or failure handling—material gaps for a mutation/upload tool.

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

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

Two concise sentences with no filler. The action is front-loaded, and the second sentence adds meaningful behavioral detail without repeating schema 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 3-parameter tool with full schema coverage, the description covers the essential invocation behavior: source path, destination path, connection requirement, and directory recursion. Overwrite/conflict semantics and return values are not detailed, but they are secondary for this straightforward upload 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 coverage is 100%, so the baseline is 3. The description adds value by clarifying that localPath may be a file or directory and that remotePath is on the connected remote host, going beyond the bare schema descriptions.

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

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

States an explicit verb ('Upload') with a clear resource scope ('local file or directory to a connected remote host via SFTP'). The local-to-remote direction and recursive behavior clearly distinguish it from siblings like sftp_download and sftp_read.

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

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

The description explains what the tool does but provides no guidance on when to use it versus alternatives such as sftp_write, sftp_download, or ssh_exec. It implies an active SFTP connection is required but never states exclusions or selection criteria.

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

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

With no annotations provided, the description carries the full burden of disclosing side effects. It explicitly states 'Creates or overwrites the file,' which is the key destructive behavior an agent must know. It does not mention permissions, error behavior, or encoding, but for a simple write tool the main risk is covered.

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

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

The description is two short sentences. The first front-loads the action and target; the second adds the important overwrite behavior. There is no filler or redundant 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?

For a tool with only three simple parameters and no output schema, the description adequately covers purpose, behavior, and the prerequisite of a connected host. It does not describe return values or failure modes, but these are less critical for a write operation and no output schema exists to elaborate.

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

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

Schema description coverage is 100%, and each parameter (content, remotePath, connectionId) already has a clear description. The tool description adds no additional parameter-specific semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action: 'Write content to a file on a connected remote host via SFTP' and notes it 'Creates or overwrites the file.' It is specific about the verb and resource, but it does not explicitly differentiate from sibling tools like sftp_upload, which also writes files remotely but presumably starts from a local file.

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

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

The phrase 'on a connected remote host' gives important context that an existing connection is required, which is a useful usage constraint. However, there is no explicit guidance about when to prefer this tool over alternatives such as sftp_upload, sftp_download, or sftp_read, leaving some inference to the agent.

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

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

With no annotations provided, the description carries the behavioral transparency burden. It usefully discloses the scope of data collection, but it does not mention whether the diagnostic changes anything on the server, whether elevated permissions are needed, how long it may take, or how connection failures are handled.

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, well-structured sentence that front-loads the action and then provides a scannable list of collected data. Every phrase adds value and there is no redundant or filler 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?

For a tool with one required parameter and no nested objects, the description adequately informs an agent what to expect from the diagnostic. The lack of an output schema is partially offset by the explicit list of collected information; minor gaps remain around return format and failure 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 coverage is 100% — connectionId is fully described as the connection ID of the server to analyze. The description adds no extra parameter-specific meaning beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb and resource ('Run a comprehensive diagnostic on a connected remote server') and enumerates concrete categories it collects: system info, CPU/memory/disk, network ports, recent errors, Docker containers, and GPU status. This clearly differentiates ssh_analyze from siblings like ssh_status and ssh_logs.

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

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

The phrase 'in one shot' implies using this tool when a broad overview is needed rather than running multiple individual commands, but it does not explicitly name alternatives or provide when-not-to-use guidance. Usage context is implied rather than stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that a connection is established and that a connectionId is returned for later operations, and it highlights jump host support. However, it does not explain connection lifecycle, failure behavior, or whether the connection persists until ssh_disconnect.

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 three concise sentences. The core action is front-loaded, and each sentence adds distinct information: what the tool does, the jump host capability, and the return value. There is no fluff or repetition.

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

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

The description is adequate for a 7-parameter tool with no output schema and no annotations, but it has clear gaps. It does not state the minimal set of required fields, connection lifecycle, or how the connectionId feeds into sibling tools. The rich schema compensates for some of this, but the description alone leaves important context implicit.

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

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

Schema description coverage is 100%, so the schema already documents all parameters, including alias as connectionId and the jumpHost structure. The description adds minimal parameter-level insight beyond restating jump host support, so the baseline score of 3 applies.

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

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

The description uses a specific verb and resource: 'Establish an SSH connection', and adds meaningful detail about jump hosts and returning a connectionId. This clearly differentiates it from execution and file-transfer siblings like ssh_exec and sftp_read, though it does not explicitly name alternatives.

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

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

The description implies usage context by mentioning jump hosts for internal networks and returning a connectionId for subsequent operations. However, it never explicitly states when to use this tool versus alternatives such as ssh_host_add or ssh_exec, nor does it give exclusions or 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 carries the full behavioral disclosure burden. It states the action ('Disconnect') but does not explain side effects such as whether the connection becomes invalid, whether any associated resources are cleaned up, whether the operation is idempotent, or what happens if the connection ID is invalid. For a state-changing operation, this level of disclosure is insufficient.

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, front-loaded sentence that states exactly what the tool does without excess words. Every word earns its place, and the critical constraint ('existing') is included.

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

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

The tool is simple, with one well-documented parameter and no output schema. The description is minimally sufficient for an agent to invoke it, but it omits behavioral details such as success/failure indicators, error conditions, and what state change the caller should expect. Given the absence of annotations and output schema, a slightly richer description would be needed for full completeness.

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

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

The schema already fully documents the only parameter with a clear description: 'The connection ID returned by ssh_connect.' This gives the agent provenance for the parameter. The tool description adds no additional semantic meaning, so the baseline of 3 is appropriate given high schema coverage.

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

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

The description uses a specific verb ('Disconnect') and a clear resource ('SSH connection'), making the tool's purpose unmistakable. It distinguishes itself from every sibling tool by naming the exact lifecycle operation, with no ambiguity about whether it connects, executes, or transfers files.

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 'existing SSH connection' clearly implies a prerequisite: the connection must already have been established, presumably via ssh_connect. It also implies the appropriate context is when an open connection should be terminated. It does not explicitly name alternatives or exclusions, but the tool's role is obvious in the sibling set, so no further routing is needed.

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 disclosure burden. It clearly discloses that stdout, stderr, and exit code are returned, which is useful. But it does not warn about possible side effects of arbitrary command execution, failure modes, or what happens if the connection is missing.

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

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

The description is two short sentences with no filler. It front-loads the core action and immediately adds the key return information. Every word contributes value.

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

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

For a simple three-parameter tool with no output schema, the description covers the essential action, the connection prerequisite, and return values. It could be more complete by mentioning side effects or when to use ssh_exec_script, but it is largely sufficient for an agent to call 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 100%, so the schema already explains command, timeout, and connectionId. The description adds no parameter-specific meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Execute') with a clear resource ('a single command on a connected remote host') and explicitly states the return values. The term 'single command' helps distinguish this from the sibling ssh_exec_script, which likely executes scripts rather than one-off commands.

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 'single command' implies this is not the tool for scripts, and 'connected remote host' implies a prerequisite connection. However, it never explicitly states when to prefer ssh_exec_script or another sibling, nor does it mention that an active connection is required via connectionId.

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 disclosure. It reveals that the script executes via bash -s over an existing connection, but it does not state whether stdout/stderr are captured, what happens on non-zero exit, whether the call blocks until completion, or that arbitrary scripts can have destructive side effects on the remote host.

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

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

Two sentences with no filler; the core action is stated first and the key mechanism follows. Every word contributes and the description is easy to scan.

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

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

For a tool that runs arbitrary remote code, the description omits important operational details such as return value/output capture, error propagation, timeout behavior, and connection prerequisites. With no output schema and no annotations, this is a meaningful gap.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds real value by specifying that the script parameter is fed via stdin to bash -s, which clarifies execution semantics and shell context beyond the schema's generic 'Multi-line bash script to execute'.

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

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

Description starts with a precise verb ('Execute') and identifies a specific resource (multi-line bash script on a connected remote host). The added mechanism ('passed via stdin to bash -s') distinguishes it from sibling ssh_exec, making the tool's unique role clear.

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

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

The description implies this is for multi-line scripts, but it never explicitly says when to prefer this over ssh_exec or any other sibling. An agent must infer the usage boundary from the 'multi-line script' and 'stdin to bash -s' wording rather than being told.

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

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

The description indicates a read-only, persistent log query via 'Query' and 'Returns', and it notes the data is kept for traceability. With no annotations provided, it could additionally mention ordering, default scope, or return structure, but the basic non-mutating behavior is clear.

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

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

The description is two concise sentences with no redundant phrasing. The core query behavior and the practical purpose are stated directly and efficiently.

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

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

For a simple read-only log query, the description plus the fully documented schema provide enough information to understand what the tool does and what parameters control it. The main missing piece is explicit guidance on how this differs from ssh_logs and what the returned entries look like, since there is no output schema.

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

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

The input schema already covers all three parameters with descriptions, defaults, and an enum, so the description does not need to add much. It adds no additional parameter context, but the 100% schema coverage makes a baseline score of 3 appropriate.

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

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

The description uses a specific verb ('Query') and resource ('persistent operation log'), names the operation types returned, and states the traceability purpose. It does not explicitly differentiate from the sibling ssh_logs, but 'persistent operation log' and 'past SSH operations' make the scope reasonably clear.

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

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

The description gives a clear use case: reviewing what was done on a server for traceability. However, it does not explicitly explain when to use this tool versus ssh_logs or ssh_status, nor does it mention any exclusions or preferred scenarios.

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

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

There are no annotations, so the description carries the behavioral burden. It does disclose a key trait: saved credentials can be reused later without re-entry. However, it does not mention what happens on duplicate aliases, whether configuration is overwritten, authentication precedence, or security/storage implications, which matters for a mutation tool.

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

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

Two sentences, no filler, and the core purpose is front-loaded in the first sentence. It is appropriately sized for a tool whose parameter details live in the schema.

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

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

Given 9 parameters, a nested jumpHost object, and no output schema or annotations, the description gives a clear workflow but leaves meaningful gaps: it does not clarify add vs update semantics, duplicate-alias behavior, auth method selection, or return/error behavior. Schema richness compensates partially, but not fully.

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

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

The input schema covers 100% of parameters, so the schema already documents host, port, tags, alias, jumpHost, password, username, privateKey, and description. The description adds some functional context for alias by stating it is used as the ssh_connect handle, but does not add detail about other parameters 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?

The description uses a specific verb ('Save') and resource ('SSH host configuration'), and states the downstream workflow: connecting with just the alias via ssh_connect. This clearly differentiates it from connection/execution tools in the sibling list.

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

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

It explains when to use this tool: to persist a host configuration for quick access, then use ssh_connect with the alias. It does not explicitly name alternatives like ssh_host_update or state when not to use it, so there is room for more explicit routing.

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 present, so the description carries the full transparency burden. It clearly indicates a read-only listing operation and adds the alias/ssh_connect relationship, but it does not disclose details such as tag-filtering behavior, authentication requirements, or output shape.

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

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

The description is two short sentences: the first states the core action and the second provides a useful cross-reference to ssh_connect. There is no redundant language or filler.

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

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

For a simple list tool with one optional parameter, the description is adequate but leaves the optional tag filter unmentioned and gives no output format, which matters because there is no output schema. The alias/ssh_connect note partially compensates, but the definition would benefit from one sentence about tag filtering.

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

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

Schema coverage is 100%, and the only parameter, tag, already has the description 'Filter by tag'. The tool description does not add any parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

The description names a specific verb ('List') and resource ('saved SSH host configurations'), making the tool's function immediately clear. It also states how the output relates to ssh_connect (by alias), which distinguishes it from management siblings like ssh_host_add/update/remove and from ssh_history.

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

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

The description implies when to use it—when a caller needs to see available saved SSH hosts—and mentions that the resulting aliases can be used with ssh_connect. However, it does not explicitly state when to prefer this over alternatives or mention any exclusion conditions.

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. 'Remove' signals a destructive action, but nothing is disclosed about irreversibility, behavior when the alias does not exist, whether active connections to that host are affected, or what the tool returns. For a deletion operation with zero annotation coverage, 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?

The description is a single compact sentence stating verb and object with zero filler. The destructive intent is front-loaded in the first word, and every word earns its place.

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

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

The tool is simple (one required parameter, no output schema), and the description plus schema cover the core invocation need. However, with no annotations and no output schema, an agent is left uninformed about failure modes and side effects of an irreversible deletion, so the definition is adequate but leaves 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 100%—the single 'alias' parameter is already documented as 'Alias of the host to remove'. The description adds no further parameter-level meaning, such as where to discover valid aliases or whether matching is case-sensitive, so the baseline of 3 applies.

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

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

The description pairs a specific verb ('Remove') with a precise resource ('a saved SSH host configuration'), which clearly distinguishes it from sibling tools like ssh_host_add, ssh_host_update, ssh_host_list, and ssh_disconnect. The qualifier 'saved' clarifies it operates on persisted configuration rather than live connections, so an agent can tell it apart without opening 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 purpose statement implies the natural use case—remove a saved host when it is no longer needed—but the description offers no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as ssh_host_update for modifying rather than deleting an entry. Usage context must be inferred from the tool's name and sibling set rather than stated.

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

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

There are no annotations, so the description carries the full behavioral burden. It does disclose that 'No credentials needed' and indicates a metadata update rather than a remote operation. However, it does not state whether tag/notes updates replace or merge existing values, or what happens when the alias is not found.

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

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

Two sentences, front-loaded with the verb and resource, and both sentences carry useful information. The 'No credentials needed' detail is valuable and not 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?

The description plus schema adequately cover the three updatable fields and the intended use case. However, with no annotations and no output schema, the lack of clarity about overwrite vs. merge behavior and the absence of any response/error semantics leave meaningful gaps for an agent invoking a mutation.

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

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

Schema description coverage is 100%, and each property already has a description, so the main description adds no new parameter-level contract. It adds context that notes 'accumulate knowledge for future sessions,' but this does not materially change how parameters should be populated.

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

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

The first sentence names a specific verb ('Update') and resource ('saved host'), and enumerates the exact fields affected: 'notes, description, or tags.' This clearly distinguishes it from ssh_host_add, ssh_host_remove, and the SSH execution/connection tools by focusing on metadata of an existing host.

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 second sentence gives clear situational context: 'Use this to record findings, document issues, or enrich the host profile based on what you learn during operations.' It does not explicitly name alternatives or exclusions, but the intended use is obvious relative to the sibling tool list.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the key stateful trait—follow=true makes subsequent calls return only new lines and equates this to tail -f—and notes the supported log backends. It does not discuss connection state or limits, but there is no contradiction.

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?

Three short sentences with no filler; purpose, source modes, and follow behavior are front-loaded. Every sentence adds useful operational 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 eight parameters and a stateful follow mode, the schema covers parameter meanings and the description covers the stateful semantics, so the invitation is actionable. Without an output schema, a bit more about the exact response shape or how to end follow would be ideal, but the core use is complete enough.

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

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

Schema description coverage is 100%, so the structured fields already document all eight parameters in detail. The description only lightly reinforces source types and follow semantics rather than adding new parameter-level meaning, so it stays at the baseline.

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

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

Description states a specific verb-resource pair ('Query logs from a remote server') and enumerates the supported source kinds (file tailing, journalctl, Docker), making the tool's role unambiguous. This clearly separates it from sibling tools like ssh_exec, ssh_status, or sftp_read even without naming them.

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

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

The appropriate context is clear: this is the tool for retrieving log output over SSH, with mode-specific guidance for file, journalctl, and Docker sources, plus follow behavior. It does not explicitly name alternatives or give when-not-to-use conditions, so it misses the top bar for explicit routing.

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 must carry the burden of behavioral disclosure. It conveys that the tool is a read-only status view and what output fields will be shown, but it does not mention whether an active session is required, what happens when there are no active connections, or any side effects.

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

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

The description is a single, tightly worded sentence with no filler. It front-loads the main action and resource, then adds the relevant output details, making it easy for an agent to parse quickly.

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

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

For a zero-parameter status tool with no output schema, the description is reasonably complete: it names the resource, the scope, and the returned fields. It could add a line about prerequisites or behavior with no active sessions, but this is a minor gap for such a simple 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?

The tool has zero parameters and an empty input schema, so parameter semantics are not a concern. The description's 'all active SSH connections' clarifies the scope without needing to describe parameters.

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

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

The description uses a specific verb ('Show') and a clear resource ('status of all active SSH connections'), then lists the exact data fields included: host, uptime, and command count. This clearly distinguishes it from siblings like ssh_history, ssh_logs, and ssh_exec, which have different purposes.

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 makes it clear this tool is for viewing connection status, not for executing commands or transferring files, so an agent can infer when to reach for it. However, it does not explicitly name alternatives or state when not to use it, such as 'use ssh_logs for historical records'.

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