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

With no annotations provided, the description carries the behavioral burden. It explicitly discloses that for an unknown server, credentials are NOT saved ('доступы НЕ сохраняются') and that a next_action will require asking the user for a name and calling ssh_save_server. It also warns not to fabricate a name. This is valuable behavioral context that prevents the agent from inadvertently persisting credentials or guessing server names. However, it does not describe the success response or side effects (e.g., whether a session is kept open), so it's not fully comprehensive.

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

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

The description is concise and front-loaded. The first sentence states the primary purpose. The second sentence delivers the critical edge case (unknown server) and an explicit instruction to the agent. There is no filler or repetition; every sentence earns its place. The formatting is clear and easy to parse.

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

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

The description covers the main flow and the unknown-server edge case, but it omits details about the successful connection outcome (e.g., what happens after connection, whether a session object is returned) since there is no output schema. It also does not explain parameters like port and probe, which have no schema descriptions. Given the tool has 8 parameters and no annotations, the description is not fully sufficient for an agent to invoke it correctly in all scenarios, but it provides the most critical 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 coverage is only 25% (2 of 8 parameters have descriptions in the schema). The description compensates partially by mentioning 'логином и паролем/ключом' (login and password/key), which maps to user, password, key_file, and passphrase. However, it does not clarify the purpose of port or probe, nor does it elaborate on the save_as parameter beyond what the schema says. Given the low coverage, the description should offer more parameter guidance, but the authentication context is a useful contribution.

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

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

The description clearly states the tool's function: 'Подключиться к серверу по имени либо по адресу с логином и паролем/ключом' – connect to a server by name or address with login and password/key. It specifies the resource (server) and the action (connect), and distinguishes it from sibling tools like ssh_run or ssh_upload by its focus on establishing a connection. The unknown-server branch is also described, making the purpose unambiguous.

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

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

The description provides clear context for when to use this tool: when a user wants to connect to a server. It also instructs the agent on handling an unknown server: do not invent a name, and expect a next_action to prompt for a name and call ssh_save_server. While it doesn't explicitly mention alternative tools (e.g., ssh_shell_open for interactive shell), the condition of unknown server gives practical guidance. A full exclusion list is not necessary given the tool's self-explanatory 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 burden. It discloses a key behavioral trait: streaming through a local temporary file, implying no direct server-to-server connection and potential disk usage. It does not mention cleanup or authentication details, but the core behavior is transparent.

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

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

The description is two concise sentences, with the core mechanism (streaming via temp file) front-loaded. Every sentence contributes meaning without redundancy.

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

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

For a simple four-parameter tool with no output schema, the description covers the essential behavior and rationale. It omits minor details like authentication prerequisites or error conditions, but the core action and mechanism are sufficiently explained for an agent to use 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 the description does not elaborate on any of the four parameters (src_server, src_path, dst_server, dst_path). The parameter names are self-explanatory, but the description adds no semantic value, formats, or constraints beyond what the names imply.

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

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

The description states a specific verb ('transfer') and a precise resource (a file between two servers via this machine). It clearly distinguishes itself from sibling tools like ssh_upload/download or ssh_run by its cross-server copy purpose.

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

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

The description explains the use case: transferring between servers when they lack mutual trust, because the streaming via a local temporary file avoids trust requirements. It does not explicitly name alternatives or exclusions, but provides clear contextual guidance.

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

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

With no annotations, the description carries the full burden. It discloses that the connection, sessions, and tunnels are closed, which is a destructive action, but it doesn't discuss side effects like termination of running commands, reversibility, or any permissions needed. No additional behavioral context such as idempotency or confirmation requirements is given.

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

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

The description is a single, efficient sentence that front-loads the core action and scope. Every word contributes to the meaning; there is no redundancy 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 one-parameter disconnect tool, the description covers the basic action but omits essential context for a mutating operation: there is no note about return values, errors, or whether it works when no connection exists. Given there is no output schema or annotations, the description is minimally sufficient but leaves gaps for an agent to safely invoke it.

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

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

The schema's only parameter 'target' is completely undocumented in the description. With 0% schema description coverage, the description should explain what 'target' refers to (e.g., a server identifier, an optional IP, or a connection name), but it provides no meaning. The default null and string type offer no clue, so an agent cannot know how to fill this parameter 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 states a specific verb ('close') and a clear resource ('connection') and explicitly distinguishes itself from sibling tools by noting it closes 'together with its sessions and tunnels,' which differentiates it from ssh_shell_close and ssh_tunnel_close. It makes the scope of the operation unmistakable.

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

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

No guidance is provided on when to use this tool versus alternatives such as ssh_shell_close or ssh_tunnel_close. It doesn't mention that this is the comprehensive disconnect or when a more targeted close might be appropriate. The use case is left entirely 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does tell the agent the operation will download and verify a checksum, but it omits important behaviors such as whether the local file is overwritten, what happens on checksum mismatch, and how max_bytes is enforced. The disclosed information is useful but far from complete.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently communicates the operation and the validation step without redundancy.

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

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

For a tool with four parameters, no annotations, and no output schema, the description is too sparse. It does not explain return values, failure behavior, checksum verification semantics, overwrite policy, connection prerequisites, or how max_bytes limits the download. The agent has enough to guess intent but not enough to invoke the tool safely and predictably.

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, so the description must compensate. It loosely conveys the roles of server, remote_path, and local_path by saying 'from the server to this machine', but it does not document max_bytes or add detail beyond the parameter names. Partial compensation, but a clear gap remains.

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 action: download a file from a server to the local machine, with an additional checksum verification step. This distinguishes it from sibling tools like ssh_upload (reverse direction) and ssh_file_read (reading rather than transferring a 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 description gives the core action but provides no guidance on when to choose this tool over alternatives such as ssh_file_read or ssh_upload, and no prerequisites like an active SSH connection. The agent must infer usage context from the tool name and siblings.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says facts are re-read; it does not explain whether this mutates local cached state, requires an active connection, how long it might take, what the return value looks like, or what happens on failure.

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

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

A single, front-loaded sentence that names the action and the fact categories with no filler. Every word contributes to understanding what the tool does.

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 adequately conveys the tool's purpose and scope. However, it omits behavioral details like return format, side effects, or prerequisites, leaving significant gaps for an agent that needs to invoke it safely and interpret results.

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 does not directly document the 'server' parameter or its expected format. The description only indirectly links the parameter to the target server, adding minimal meaning beyond the schema's name and type.

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 ('Перечитать' / refresh) and a concrete resource: facts about a given server, enumerating OS, kernel, disk, installed software, and ports. This clearly distinguishes it from siblings like ssh_status, ssh_run, or ssh_file_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 implies the tool is used when you need current server facts refreshed, but it gives no explicit guidance about when to prefer it over alternatives or when not to use it. There is no mention of prerequisites such as an established connection or cached facts.

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 burden. It discloses a key behavioral trait: large files are truncated ('Большие файлы обрезаются'). However, it doesn't mention whether the operation is read-only (safe), whether it requires an active connection, or what happens if the file doesn't exist. The truncation behavior is useful but incomplete for a 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 description is very short: two sentences. The first sentence states the purpose, and the second adds a critical behavioral note. It's front-loaded and efficient, 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?

For a tool with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't explain the return format, error behavior, or how max_bytes interacts with truncation. An agent would need to infer parameter semantics from names alone, which is risky for a file-reading 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%, so the description must compensate. It mentions 'text file' and 'server' but doesn't explain the parameters: server, remote_path, or max_bytes. The truncation note hints at max_bytes but doesn't explicitly connect it. With 3 parameters and zero schema descriptions, the description adds minimal semantic value beyond the parameter names.

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

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

The description states a specific verb and resource: 'Прочитать текстовый файл с сервера' (read a text file from the server). It distinguishes itself from siblings like ssh_file_write, ssh_upload, ssh_download, and ssh_list_dir by focusing on reading a file's contents. However, it doesn't explicitly name a sibling alternative, so it doesn't fully differentiate from tools like ssh_download or ssh_shell_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 implies usage: use this when you need to read a text file from a server. It doesn't explicitly state when not to use it or mention alternatives like ssh_download for binary files or ssh_shell_read for command output. The truncation note ('Большие файлы обрезаются') gives a hint about limitations but no explicit routing guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the atomic write sequence (hash, temporary file, verify, rename), guarantees the production file never contains unverified content, and states the idempotent behavior with changed=false on repeated calls. This goes beyond the schema and provides critical safety context, though it omits details on backup creation, validation failure handling, and owner/mode 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 three concise sentences, front-loaded with the core purpose in the first sentence and then explaining the deliberate order and guarantees. Every sentence earns its place without filler or redundancy. It is appropriately sized for the complexity it addresses.

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 7 parameters, 3 required, no output schema, and no annotations, the description is incomplete. It explains the core atomic/idempotent behavior but does not document parameters, return values (beyond the changed flag), side effects (backup, owner changes), or failure modes. An agent would need additional information to correctly invoke the tool with proper values for mode, owner, backup, and validate.

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 only 14% (only the 'validate' parameter has a description). The tool description adds no explanation for the seven parameters—server, remote_path, content, mode, owner, backup, validate. It does not clarify expected formats, defaults (beyond schema), or how parameters interact (e.g., backup behavior, validate command syntax). The description does not compensate for the low schema coverage, leaving the agent to guess parameter meanings.

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+resource: 'Put a file on the server' (Положить файл на сервер), and adds defining characteristics 'atomically and idempotently' (атомарно и идемпотентно). This distinguishes it from simpler upload tools like ssh_upload, though it does not explicitly name alternatives. The purpose is specific, but sibling differentiation is implicit rather than stated.

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

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

The description implies when to use the tool through its emphasis on atomicity and idempotency (e.g., for safe, repeatable writes), but it does not explicitly state when to prefer this over siblings like ssh_upload or ssh_run, nor does it mention any exclusions or alternative selection criteria. This is implied usage, not explicit guidance.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses that the operation is a mutation (removing a host-key pin) and adds security-critical context about not retrying silently. It does not detail every side effect, but for this narrow tool the core behavior is clearly communicated.

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 deliver the action, the condition, and the rationale with no filler. The most important warning is placed immediately after the action, making the structure efficient and easy to parse.

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

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

For a two-parameter tool with no output schema, the description covers what it does, when to use it, and why misuse is dangerous. It does not explicitly state the postcondition (e.g., reconnecting to accept the new key), but the essential context for correct invocation is present.

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

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

Schema description coverage is 0% and the description does not mention host or port semantics beyond the implicit 'host' in the tool phrase. The parameters are simple and self-explanatory, but the description does not compensate for the missing schema descriptions, so the agent gets minimal additional guidance.

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

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

The description opens with a specific verb and object: 'Снять закрепление ключа хоста' (unpin/remove the host key pin). This clearly identifies the operation and distinguishes it from siblings like ssh_forget_server (which forgets a server) and ssh_keys_list (which lists 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?

It explicitly states the only condition under which the tool should be called: after the user has confirmed the server was recreated. It also gives a negative condition by warning that silently retrying after a key mismatch is exactly what an interceptor wants, guiding the agent not to abuse the tool.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It transparently notes that notes are deleted only on explicit request, preventing a common misconception. However, it does not disclose other side effects, such as whether active connections are affected, whether deletion is reversible, or what happens to related memory/notes beyond the single caveat.

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

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

Two short, front-loaded sentences with no filler. The primary action is stated first, and the important caveat about notes is placed second. 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?

For a destructive tool with no annotations and no output schema, the description gives the core action and one key side-effect, but it omits details like the exact role of delete_memory, the behavior for unknown names, and any irreversible consequences beyond notes. It is adequate for a basic call 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 coverage is 0%, so the description must compensate. It adds meaning by indicating that note deletion is controlled by an explicit request, effectively hinting at the delete_memory parameter. However, it does not explicitly map 'name' to the server identifier or explain that delete_memory defaults to false.

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 ('Удалить' – delete) and the resource ('сохранённый сервер' – saved server), which distinguishes it from siblings like ssh_forget_host_key (host key) and ssh_save_server (save). It also adds a meaningful caveat about notes, further clarifying 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?

The description implies usage: call this to remove a saved server, and notes are kept unless explicitly removed. However, it does not explicitly state when to use this tool versus alternatives such as ssh_forget_host_key, nor does it mention prerequisites like the server needing to be disconnected.

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 behavioral disclosure. It states the guide covers non-working paths and saves attempts, which is useful context, but it never explicitly says the tool has no side effects and only returns documentation. For a guide, this is inferable, so the gap is moderate.

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 purpose first locked in the first sentence, followed by concrete usage triggers and a value proposition. No filler 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?

For a single optional parameter and no output schema, the description is sufficient: purpose, when to use it, and topic categories are available. It does not describe the return shape, but that is not critical for a guide tool.

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

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

Schema coverage is 100% with topic values fully described in the parameter description. The tool description adds situational context (when to read which guide) but no new meaning about the topic parameter itself, 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?

The description identifies the tool as a detailed guide ('Подробное руководство') for the SSH toolset, which is clearly distinct from the operational sibling tools. It does not explicitly say it returns documentation text, but 'Прочитайте нужную тему' makes the informational purpose 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?

It gives explicit triggers: read before 'first interactive session, first tunnel, or saving a new server'. It does not state when-not or name alternatives, but as the only guide among operation tools, the when-to-use context is clear.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states that the tool shows a log; it does not explicitly confirm that the operation is read-only, what type of actions are logged, how far back the history goes, or whether the data is session-specific or persisted. This is a significant transparency gap for a tool with no annotation safety hints.

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 that communicates the core purpose with no filler. It contains exactly the essential information without superfluous detail, making it appropriately concise and well-structured.

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 relatively simple—two optional parameters and no output schema. The one-sentence description gives a basic idea of the tool's purpose, but for a history/log tool it lacks useful contextual details such as ordering of results, whether the log covers all servers when 'server' is null, and what the output entries look like. It is minimally adequate but leaves room for improvement given it has no annotations or output schema to compensate.

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 description coverage is 0%, so the description must compensate by explaining the parameters. It does not mention 'limit' or 'server' at all. While the parameter names are fairly self-explanatory and the schema provides defaults, the description adds no semantic detail about their behavior (e.g., how filtering by server works, whether limit is the most recent entries).

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

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

The description clearly states the tool shows a journal/log of executed actions with servers, using a specific verb ('Показать') and resource ('журнал выполненных действий'). It also specifies the content scope ('что и когда делали с серверами'), which distinguishes it from all sibling tools, none of which are history/log-focused.

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

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

The description implicitly indicates when to use the tool (to review what actions were performed on servers), but it provides no explicit guidance on when not to use it or how it compares to alternatives. There is no mention of prerequisites, such as whether a server must be selected or whether the history covers all servers.

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 behavioral burden. It discloses that by default the tool only shows what will be imported (dry-run), which is a useful behavioral trait. However, it does not mention the dry_run parameter explicitly, nor any side effects when dry_run is false (e.g., whether it modifies files or requires confirmation). This is a partial disclosure; the core behavior is clear but not comprehensive.

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

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

The description is concise, only two sentences, and front-loads the main action (import) and the resource. The second sentence explains a critical default behavior. There is no redundancy; every sentence earns its place. However, it is slightly sparse—it could add a hint about output format 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?

The tool is a one-off import operation with only two parameters, one of which is documented. The description covers the primary purpose and the dry-run default, which is essential for safe usage. However, it omits details like what the output looks like (since no output schema is provided) and what happens when dry_run=false (e.g., writes to config). For an import tool, this is a moderate gap but not severe given the simplicity.

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 50%, meaning the 'path' parameter is documented in the schema but 'dry_run' is not. The description mentions the dry-run behavior indirectly ('По умолчанию только показывает'), which adds semantic value beyond the schema's default value. However, it does not elaborate on the exact format of 'path' or the meaning of 'dry_run' beyond the boolean. The description adds some context but does not fully compensate for the undocumented parameter.

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

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

The description clearly states the tool's purpose: importing servers from a legacy block-based servers.env file. It uses a specific verb ('Импортировать') and resource ('старый блочный servers.env'), effectively distinguishing it from sibling SSH tools which focus on connection, file operations, and shell management.

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 the primary use case (importing legacy servers) but does not explicitly state when to use it vs. alternatives. It mentions a dry-run default, which hints at a safe preview mode, but lacks explicit exclusions or reference to any alternative import tools. Given the sibling list, no other tool does import, so the context is clear enough, though not explicit.

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

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

With no provided annotations, the description carries the full behavioral burden, and it only says 'show', implying a read-only operation without stating output format, error behavior, or whether a connection is needed. No additional behavior context (e.g., side effects, performance, auth) is provided.

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

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

A single sentence containing only the essential information—what the tool shows and for which sibling. Nothing extra, and the content is front-loaded.

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

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

For a no-parameter, list-only tool without an output schema, the description provides a usable starting point but leaves ambiguity about what 'keys' are and what the returned data looks like. It is sufficient to invoke the tool, but not fully complete for an agent to anticipate result directly.

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?

This tool has zero parameters and 100% schema description coverage, so the input schema already fully describes the input. The baseline of 4 applies because the description does not need to add parameter detail; it would only be 5 with extra relevant context like output shape for the list.

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

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

The description names a concrete action (show key names) and ties it to a specific sibling tool, `ssh_shell_send`, which helps differentiate it from the many other SSH tools. The wording is mostly clear, though the exact meaning of 'keys' (keyboard keys vs. authentication keys) is implied 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?

Usage context is implied but not explicit: mentioning `ssh_shell_send` signals that this list is meant to be consulted before using that tool. There is no when-not guidance or mention of alternative listing tools among the siblings, so the agent must infer the intended workflow.

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 disclosure burden. It only states the action; it does not mention how limit affects results, the returned data shape, ordering, hidden files, error behavior, or whether the operation is purely read-only.

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 for a simple listing tool, though the brevity comes at the cost of missing behavioral/parameter detail.

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

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

With no annotations and no output schema, the one-line description is not complete enough for an agent to know what to expect from a call. It omits return format, result limit behavior, and how server/remote_path values should be supplied.

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 needs to explain the parameters. It adds minimal context by implying remote_path is a directory and server is the remote host, but it leaves limit meaning, defaults, and input constraints 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?

The description uses a specific verb and resource: 'show the contents of a directory on the server.' This clearly identifies the operation as a remote directory listing and distinguishes it from file read/run tools in the sibling set, though it does not explicitly 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?

The purpose statement implies when to use it: when the agent needs to list a remote directory. However, it gives no explicit guidance about alternatives such as ssh_file_read or ssh_run, and no conditions for when not to use this tool.

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

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

With no annotations, the description carries the behavioral burden. It does disclose a meaningful trait: the note is durable across restarts and new sessions. It does not, however, describe whether the note overwrites or appends, what authorization is needed, or what the call returns.

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, tight sentence that front-loads the core action and the most important behavioral guarantee. Every word adds value and there is no redundancy.

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

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

For a write operation with no annotations and no output schema, the description is too sparse. It omits crucial context like whether the note is appended or replaced, how the server is identified, and what happens with tags. The agent is left to infer too much.

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 only clarifies that the note relates to a server, leaving 'server' identifier format, 'note' content expectations, and the optional 'tags' parameter 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?

The description uses a specific verb ('Записать') and resource ('о сервере'), and adds the key property that the note persists across restarts and new sessions. However, it does not explicitly distinguish itself from siblings like ssh_notes_get, so it falls just short of full 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?

The persistence detail implies when the tool should be used: when a server note needs to survive restarts and sessions. But there is no explicit guidance on when not to use it or which alternative to prefer.

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 behavioral disclosure. It only says 'read', which implies a safe read operation, but it does not disclose output format, potential errors, authentication needs, or what distinguishes 'facts' from 'notes'.

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

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

The description is a single efficient sentence with no filler or repetition. It is front-loaded with the action and the resource, though it could be longer to add necessary context without losing 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?

Given the large set of sibling tools and the absence of annotations or an output schema, this minimal description is insufficient. It does not explain the return value, pagination behavior, or how this tool relates to ssh_notes_add and ssh_facts_refresh.

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, so the description must compensate, but it does not explain the meaning of 'limit' or 'query'. It only implies that 'server' is the target server, leaving the other parameters underspecified.

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

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

The description uses a clear verb ('read') and identifies the resource ('facts and notes about the server'). It is understandable on its own, though it does not differentiate itself from sibling tools like ssh_notes_add or ssh_facts_refresh.

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 use this tool versus alternatives. There is no mention of exclusions, such as when to choose ssh_notes_add for writing or ssh_facts_refresh for refreshing facts.

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 the default behavior waits for the result, that background=true detaches the command and writes output to a file, and that larger timeouts are discouraged. However, it does not explain how exit codes, error output, or partial output are surfaced, nor what the result payload looks like.

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 well-paced sentences, one for the core action and one for the most important usage rule. There is no filler, and the key decision guidance is placed right after the purpose, making it easy for an agent to consume 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 7-parameter tool with no annotations and no output schema, this description is not complete enough. It omits semantic details for check, stdin, and max_output, and it does not describe return shape or error behavior, so an agent is likely to call the tool with incorrect or under-informed arguments.

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 has 0% description coverage, so the description must compensate for parameter meaning. It successfully explains background and timeout behaviors in depth and implies the meaning of server and command through the main sentence, but it omits meaningful guidance for check, stdin, and max_output, leaving their semantics ambiguous.

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

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

The description states the concrete action: "Выполнить команду на сервере и дождаться результата" (Run a command on the server and wait for the result). This clearly identifies the verb, resource, and behavior, and distinguishes it from interactive tools like ssh_shell_open and status tools like ssh_status, but it does not explicitly contrast it with the similar sibling ssh_run_many.

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 offers explicit and practical guidance: for anything longer than a couple of minutes (apt upgrade, docker pull) use background=true, and assume that increasing timeout instead will lead to a hung call. This gives clear when-to-use context for the background parameter, though it does not mention when to prefer alternative tools such as ssh_shell_open or ssh_run_many.

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 disclosure burden. It adds an important behavioral detail: failure on one server does not cancel the others, and per-server results and errors are returned together. It does not mention timeout or worker behavior, but the most critical parallel-execution semantics are captured.

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

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

Two short sentences, each earning its place: the first states the core purpose, the second adds the essential failure-handling behavior. No redundancy 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?

The description is sufficient for tool selection and basic invocation, but with no output schema and four parameters, it leaves gaps: it does not say how servers are identified/referenced, exactly how the result payload is structured, or what timeout/max_workers fully control. It is adequate but not fully complete for autonomous use.

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

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

Schema description coverage is 0%, and the description only paraphrases 'command' and 'servers'. It does not explain timeout units/scope or what max_workers controls, so an agent must infer those details solely from parameter names and defaults.

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

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

The description states a specific action: execute one command on multiple servers in parallel. This clearly distinguishes it from single-server tools like ssh_run and from other SSH operations such as upload, shell, or tunnel 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?

The description makes the intended use case explicit: running one command across many servers concurrently. It does not explicitly name an alternative for single-server execution, but the 'multiple servers in parallel' phrasing gives clear context for when this tool is appropriate.

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 does disclose an important side effect: with a pending_id, the live connection is renamed and no reconnection happens. However, it does not explain what happens without a pending_id, how overwrite behaves, or whether saving mutates persistent stored server data.

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

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

Two short sentences front-load the core purpose and then add the key workflow caveat. There is no filler; every sentence contributes essential 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?

Despite good high-level workflow context, the description is incomplete for the tool's complexity: 12 parameters, no annotations, and no output schema. An agent cannot fully determine behavior for the standalone save case or what happens with existing server names, overwrite, or optional connection details.

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

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

Schema description coverage is only 8%, so the description must compensate, but it only clarifies name and pending_id. The other ten parameters, including host, port, user, tags, key_file, password, overwrite, and passphrase, are left to schema names and defaults, leaving a substantial gap for a 12-parameter tool.

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

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

The description clearly states a specific action: save a server under a user-provided name. It further distinguishes itself from connection-oriented siblings by explicitly tying the tool to ssh_connect's pending_id, making its role in the workflow unmistakable.

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

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

The description explicitly says the tool is usually called immediately after ssh_connect with its pending_id, and explains that in that case the live connection is renamed without reconnecting. It gives a clear primary use case, though it does not discuss when not to use it or alternative paths.

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 only states 'close interactive session' but does not reveal what happens to the remote process, whether it blocks, if it is safe to call multiple times, or what errors could be raised. The side effects and semantics of closing are opaque.

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

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

The description is extremely terse and front-loaded, but it earns its place and nothing is wasteful. However, it may be too sparse to fully specify the tool, so I cannot give a perfect score given the lacking critical information for a safe invocation.

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

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

For a simple tool with one parameter, no annotations, and no output schema, the description is incomplete. It does not explain what a successful close does, whether a session can be reopened, or how the input parameter should be obtained. An agent could not confidently invoke this correctly based only on this text.

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

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

Schema description coverage is 0% and the description does not mention the 'session' parameter at all. An agent gets no hint that this parameter likely holds the session identifier returned by ssh_shell_open. The single parameter is completely undocumented both by the schema and the description.

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

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

The description 'Close interactive session' clearly states the action (close) and the resource (interactive session). It clearly differentiates from siblings like ssh_tunnel_close and ssh_disconnect, which affect different resources (tunnel vs. connection). Even though it omits the word 'shell', the context of the tool family makes the object unambiguous.

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 such as ssh_disconnect or ssh_shell_send. It does not mention that this should be used after ssh_shell_open or what conditions call for it. The agent is left 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 carries the burden of behavioral disclosure. It adds useful context about interactive/full-screen behavior and session lifecycle, but it does not explain what the tool returns after opening a session, how the session handle is used, or any authentication/terminal requirements.

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

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

The description is short, front-loaded with the core purpose, and then gives usage guidance, the alternative, and a lifecycle instruction. Every sentence adds value, with 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 covers when to use the toolro and alternatives, but it lacks parameter-level guidance and does not describe return values or how the interactive session is consumed by sibling tools. It is adequate for a basic understanding but not fully 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 only 17%; only 'term' has a description. The tool description does not explain the meaning of 'server', 'command', 'marker_prompt', 'cols', or 'rows'. Some parameter names are self-explanatory, but 'marker_prompt' especially remains opaque, and the description does not compensate for the low 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 clearly states that the tool opens an interactive shell on a server via the verb 'Открыть' and the resource 'интерактивную оболочку'. It further distinguishes itself by giving concrete interactive examples (nano, whiptail, htop) and by contrasting with ssh_run.

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

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

The description explicitly specifies when this tool is appropriate ('где команда что-то спрашивает или рисует полноэкранный интерфейс') and tells the agent to use ssh_run for ordinary commands. It also instructs the agent to close the session afterward.

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 that the tool sends nothing, implying a read-only operation, and is intended for long-running commands. However, it does not mention blocking/waiting behavior, session requirements, or what happens when output is still streaming.

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 focused sentence with zero filler, front-loaded with the action and then scoped to the long-running-command use case. It is appropriately concise, though slightly terse for a tool with several non-obvious 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?

The description covers only the core purpose and one usage context, while five parameters, no output schema, and no annotations remain unexplained. The tool is not fully usable without substantial inference about timeout and expect 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% and the description introduces none of the five parameters. The semantics of view, expect, idle_ms, and timeout_s are left entirely undocumented, so an agent cannot reason about how to set 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?

The description uses a specific verb and resource: 'read the remaining output of a session' and adds a critical exclusion: 'without sending anything.' This clearly distinguishes ssh_shell_read from the send-focused siblings like ssh_shell_send and ssh_shell_send_secret.

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 explicitly targets long-running commands ('для длящихся команд'), which tells an agent when this read tool is appropriate. It does not name sibling alternatives or state exclusion cases, but the context is clear enough 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?

The description makes the primary behavior clear — resizing the session window's dimensions — and hints at the expected effect on TUI output. However, with no annotations provided, it does not disclose side effects on the running session, whether existing output/scrollback is affected, or 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?

The description is short, front-loaded, and contains no filler; the first clause states the action, and the second gives the practical trigger. It is appropriately terse, though its brevity is partly responsible for the missing parameter and side-effect 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 tool with no output schema, no annotations, and 0% schema parameter descriptions, the description must carry more context. It does not say that 'session' likely refers to an open shell session from ssh_shell_open, what happens if the session is not active, or what result/error behavior to expect.

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

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

Schema description coverage is 0%, so the description must compensate for the three undocumented parameters. It adds generic meaning around resizing a window, but it never explains the semantics of 'session', valid ranges for cols/rows, or how the parameters interact with the TUI. This is an under-compensated 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 and resource: resize the SSH session window, and adds a clear use case ('useful if the TUI truncates content'). It is clearly distinct from sibling shell operations like open/send/read/close, though it does not explicitly name any alternative tool.

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

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

It provides a concrete signal for when to use the tool: when a TUI is clipping or cutting off content. It does not explicitly state when not to use it or name alternatives, but the use case is clear enough for a reasonably informed agent.

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

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

With no annotations, the description carries the honesty burden. It discloses that the function waits for a reaction and that simultaneous blind sends can cause a stuck session. However, it leaves out details about errors, return values, and session prerequisites.

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 economical: two efficient sentences cover the action and the workflow warning. Every sentence adds value, and the main action is stated first.

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 an 8+1 8-parameter tool (actually 8), no output schema, and partial parameter descriptions, the description gives useful workflow advice but omits details like the need for an open session, how the reaction is returned, and the role of timeout parameters. It is adequate for basic use, but not complete.

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

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

The schema parameter description coverage is only 38%, but the description does not add any meaningful detail about the majority of parameters. It only mentions 'text' and 'key presses' generically, providing no new insight beyond the schema.

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

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

Description states a clear action: send text and/or key presses to a session and wait for reaction. The term 'session' helps distinguish it from non-interactive sibling tools, though it does not explicitly reference aliases.

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 a usable loop workflow ('send — read — view — decide') and explicitly warns against two consecutive blind sends, which tells an agent how to use the tool. It does not name explicit alternative tools, but the general context is clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that server_password avoids passing the password through correspondence and warns that ssh_shell_send logs text, implying this tool does not log when using server_password. However, it does not explicitly state whether this tool logs, what happens when value is used directly, or any other side effects or prerequisites, leaving behavioral transparency incomplete.

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

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

The description is concise, with three sentences that front-load the purpose and provide critical security guidance. It is efficient and well-structured, with 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 tool with 5 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the role of value, idle_ms, or timeout_s, nor does it mention prerequisites like an active shell session or the expected behavior after sending. While the core usage is covered, operational details are missing, making it insufficient for an agent to call the tool correctly in all cases.

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

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

The description only mentions server_password, which is already described in the schema. It does not explain value, idle_ms, or timeout_s. Since schema description coverage is only 20%, the description should compensate for the missing parameters but does not, leaving their semantics unclear and forcing the agent to infer their purpose.

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

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

The description clearly states the tool's purpose: entering a password into sudo, passwd, or installer prompts. It distinguishes itself from the sibling ssh_shell_send by explicitly warning against using that tool for passwords, making the specific role of this tool unambiguous.

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

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

The description provides explicit guidance: prefer server_password to avoid passing secrets through correspondence, and explicitly instructs to never use ssh_shell_send for passwords because it logs the text. This gives clear when-to-use and when-not-to-use instructions with a direct alternative.

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 behavioral disclosure burden. The verb «Показать» and the 'what I already have' framing make clear this is a non-mutating inspection tool, though it does not explicitly address side effects, data freshness, or whether any live checks 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?

Two short sentences deliver the core purpose first and the usage guidance second. There is no filler; every sentence earns its place.

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

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

The tool is simple, with one optional boolean and no output schema, and the description covers purpose and usage timing well. However, the effect of the 'verbose' parameter is undocumented, and no hints about the shape or richness of the returned status are given.

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 only provides a boolean titled 'Verbose' with a default of false; the description never mentions this parameter or what verbose mode changes. Since schema description coverage is 0%, the description should compensate but 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?

The description uses the specific verb «Показать» and enumerates the exact resources it surfaces: saved servers, live connections, sessions, and tunnels. The second sentence frames it as the general 'what do I already have' overview, which distinguishes it from action-oriented sibling 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?

The description explicitly tells the agent this is the first tool to start with and defines the triggering question ('what do I already have'). It does not list exclusions or alternative tools, so it stops short of a full 5.

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 burden. It does disclose the key destructive gotcha—omitting the argument closes all tunnels. But it does not mention reversibility, error handling, or whether an explicit ID must reference an existing tunnel. Still, 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?

Two short clauses with zero filler. The core action is stated first and the behavior modifier is appended right after, making it immediately scannable and perfectly sized for its purpose.

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

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

For a one-parameter utility tool with no output schema and no annotations, the description covers the essential semantic. It could also briefly mention that nothing is returned or that non-existent tunnel IDs yield an error, but the current information is sufficient for straightforward invocation.

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

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

The description explicitly explains the meaningful behavior of the only parameter: not providing it closes all tunnels. This adds semantics beyond the bare schema, where tunnel_id merely has a null default. For a 0% schema coverage scenario, this compensates well.

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 ('закрыть' / close) and resource ('туннель' / tunnel), and the sibling context (ssh_tunnel_open) makes the purpose unmistakable. It is not a tautology and clearly differentiates from related SSH 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?

The purpose itself implies when to use it, and it does give an important operational rule about omitting the argument. However, it does not explicitly explain when to prefer this over ssh_disconnect or other siblings, nor does it provide conditions/exclusions for using 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 burden of behavioral disclosure. It adds useful behavior: the tunnel lives until the end of the Claude Code session and is reachable at a returned address. It does not mention authentication, preconditions, or cleanup detail beyond the implied session lifetime.

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

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

The description is short and front-loaded with the purpose, followed by a concrete example and a key behavioral note. It is relatively efficient, though the example is slightly specific and could be tighter.

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 six parameters, no annotations, no output schema, and a range of tunnel kinds plus many sibling tools, the description is not complete. It explains only a local-tunnel scenario and does not fully cover the tool's modes, argument expectations, or returned-address format.

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 only 33%, so the description should compensate. It explains one meaningful example for kind='local', but does not clarify server, bind, listen_port, dest_host, or dest_port semantics across local/remote/dynamic modes. This leaves too much parameter behavior to be inferred.

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

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

The description states a specific action ('open a tunnel to a server') and gives a concrete use case, which distinguishes this from sibling connection and shell tools. It could more explicitly call out SSH tunneling, but the object and behavior are 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 an example of when the tool is appropriate — exposing a locally-listening service through a tunnel — and notes the tunnel lifetime. It does not explicitly discuss when not to use it or contrast it with ssh_connect, ssh_shell_open, or ssh_run, so some guidance is present but not full.

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. It does disclose one useful behavior: it verifies the file arrived intact. However, it does not mention overwrite semantics, permissions, error handling, or what happens on verification failure, so transparency is only partial.

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 tight sentences with no filler. The core purpose is front-loaded, and the alternative guidance is placed in the second sentence. 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?

Given the absence of annotations, output schema, and any parameter descriptions, this is incomplete for a tool with 5 parameters. It explains the core operation and verification intent, but omits mode/mkdir semantics, return value, and failure behavior, which an agent would need 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%, so the description must compensate. It only implies the role of local_path and remote_path, and leaves mode and mkdir entirely unexplained. The parameter names are self-evident, but no additional semantic detail is provided.

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: upload a local file to the server, plus the added behavior of verifying it arrived intact. It also distinguishes itself from ssh_file_write by explicitly naming that sibling, so an agent can tell them apart.

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 clear routing guidance: for content the user composed, use ssh_file_write instead, because it is idempotent and creates backups. This is an explicit when-not-to-use condition with a named alternative, leaving no ambiguity about the intended scope.

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