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 mentions the basic action and file creation but does not disclose potential side effects such as permission errors, encoding issues, concurrency behavior, or resource limits. This is insufficient for a tool with no annotations.

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

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

The description is concise with two clear paragraphs and a bullet-style args list. Every sentence serves a purpose: defining the operation, highlighting efficiency, noting file creation, and listing parameters. 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?

Given no output schema and no annotations, the description covers the core usage but lacks details on error handling, permission requirements, encoding (e.g., binary vs. text), and size limits. It is adequate for a simple tool but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful context beyond the schema: 'path' is described as 'Path to the file on the remote', 'content' as 'Text content to append', and 'host' includes default behavior ('Uses default if omitted'). This adds significant value.

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

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

The description clearly states the tool appends text to a file on a remote server. The verb 'append' and resource 'file on remote server' are specific, and it distinguishes from sibling tools like ssh_write_file (which overwrites) and ssh_read_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 indicates it is efficient for large files with no read round-trip needed, and that the file is created if it does not exist. This provides clear context for when to use it, but does not explicitly state when not to use it or list alternatives beyond the implied distinction from write/read.

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 transparency burden. It states it returns status and diagnostics, implying a read-only operation, but does not detail timeout behavior or network impact.

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 two clear paragraphs: first stating purpose, second detailing diagnostics and parameter. Every sentence is informative and necessary.

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 check tool with one optional parameter and no output schema, the description covers purpose, parameter, and diagnostics adequately. Could be improved with return format 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?

The description explains the 'host' parameter as an SSH host alias from config and mentions default behavior, adding value beyond the schema's title and type. Schema coverage is 0%, so 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 clearly states the tool checks SSH connection liveliness, which is a specific verb-resource combination. It distinguishes from sibling tools (e.g., ssh_run, ssh_read_file) by focusing on connectivity diagnostics.

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 mentions what to check if connection fails (host reachability, key/agent/config), providing context for use. It does not explicitly list when not to use or alternatives, but the scope is well-defined.

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 mentions the destructive nature of deletion and explains recursive behavior (rm -r), but does not discuss permissions, error handling, or consequences beyond that.

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

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

The description is very concise, front-loaded with the main purpose, and organized cleanly into an Args section. Every sentence adds value 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?

The description covers the basic purpose and parameters but lacks information on return values, error states, or safety notes for a destructive SSH operation. With no output schema, more completeness would be beneficial.

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

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

With 0% schema description coverage, the description adds meaningful context to all three parameters: path, recursive (explains its effect with rm -r), and host (SSH host alias with default behavior). This compensates well for the lack of schema descriptions.

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

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

The description clearly states 'Delete a file or directory on the remote server.' This uses a specific verb and resource, and distinguishes from sibling tools like ssh_move (move) and ssh_mkdir (create).

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 parameter explanations but does not offer any guidance on when to use this tool vs alternatives. No explicit when/when-not or comparison to siblings like ssh_move or ssh_upload.

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?

Describes binary-safe streaming behavior and file type preservation. With no annotations, the description should cover more side effects like overwrite policy, permissions, or error scenarios. Missing key behavioral details.

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 plus an Args list. Front-loaded with main purpose, no redundant words. Every sentence serves a 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?

Covers direction, protocol, binary safety, and sibling alternative. Missing overwrite behavior and error handling, but for a simple download tool this is largely sufficient.

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?

Despite 0% schema coverage, the description adds all parameter meanings: remote_path as file path, local_dir with default ~/Downloads, host as alias with default null. This compensates for the bare schema.

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

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

The description clearly states the tool downloads a file from remote to local, specifies binary-safe and SFTP, and distinguishes from sibling ssh_upload by mentioning the reverse direction.

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?

Explicitly tells when to use this tool vs ssh_upload (sending the other way). Lacks guidance comparing to ssh_read_file for text files or mentioning precautions for large files, but the single alternative is well-addressed.

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, and the description is vague about what 'detailed information' includes (e.g., file size, permissions). It does not disclose behavioral traits beyond being a read operation.

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

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

The description is concise with two short sentences and no redundancy. However, the brevity sacrifices necessary detail, making it less effective.

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 lack of output schema, the description should explain what 'detailed information' comprises, but it does not. The tool has many siblings, and no prerequisites or return values are mentioned.

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 adds some value beyond the schema: it explains 'host' as an SSH host alias with a default. However, it does not elaborate on the format or default behavior, and the schema coverage is 0%.

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 it gets detailed information about a file or directory on a remote server, using a specific verb ('Get') and resource. This distinguishes it from siblings like ssh_read_file (reads content) and ssh_list_dir (lists contents).

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_read_file, ssh_list_dir, or ssh_find_files. The context of use is implied but 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?

No annotations are provided, so the description carries full burden. It explains the purpose and parameters but does not disclose behavioral traits such as read-only nature, permission requirements, connection prerequisites, or error handling. The tool is implied to be safe, but not explicitly stated.

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, using a clear docstring format with bullet-pointed Args section. Each parameter gets a line, and the overall length is appropriate. Could be slightly more terse, but structure is effective.

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 6 parameters, 0% schema coverage, and no output schema, the description adequately covers parameter semantics but lacks details on return format, error handling, and prerequisites like SSH connection setup. It is minimally complete for an agent to use, but gaps remain.

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 compensates well by explaining each parameter with examples (e.g., pattern: '*.py'), accepted values (file_type: 'f', 'd', ''), and defaults. It adds meaning beyond the schema's titles and types.

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 'Find files by name pattern on the remote server,' providing a specific verb ('Find'), resource ('files'), and scope ('by name pattern'). This distinguishes it from sibling tools like ssh_list_dir (lists directory without pattern) and ssh_grep (searches file contents).

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 lists parameters and their defaults, which implicitly guides usage, but it does not explicitly state when to use this tool over alternatives like ssh_list_dir or ssh_grep. No when-not-to-use or exclusion criteria are provided.

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

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

No annotations are provided, so the description carries full responsibility. It explains parameters like 'ref' and 'staged' but does not disclose whether the operation is read-only, potential side effects, error behavior, or output format. The diff nature implies read-only, but it's not explicit.

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

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

The description is concise and well-structured with a clear 'Args:' section. Each parameter is explained in one line without unnecessary detail, earning its place. 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?

Given the tool has 5 parameters, no output schema, and no annotations, the description covers parameters well but omits return value description, error handling, and prerequisites. While adequate for basic use, it leaves gaps for an AI agent regarding expected output and failure modes.

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 and does explain each parameter in detail: cwd (defaults to host's default_cwd), ref (empty for working tree diff), path (limit to file/directory), staged (--cached), host (SSH host alias). This adds significant meaning beyond the schema's name/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 clearly states the tool's purpose: 'Show git diff on the remote server.' It uses a specific verb ('Show') and resource ('git diff'), differentiating it from sibling tools like ssh_git_log (show log) and ssh_git_status (show status).

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

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

No explicit guidance on when to use this tool versus alternatives. The description lists parameters but does not provide context like use cases or exclusions (e.g., does not mention that ssh_git_log should be used for commit history).

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, and the description does not disclose whether the operation is read-only, requires special permissions, or has side effects. It implies a read operation but fails to explicitly state safety characteristics.

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 with the purpose. The argument list is clearly formatted. No extraneous information, though it could be more structured with bullet points.

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 5 parameters and no output schema, the description covers the purpose and all parameters adequately. However, it lacks behavioral details and return value information, leaving some gaps for an agent to infer.

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

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

Schema description coverage is 0%, but the description adds meaningful parameter explanations (e.g., default cwd, count, path filtering, oneline flag). This compensates well for the schema gap.

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

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

The description clearly states the tool shows git log on a remote server. While it distinguishes from sibling tools like ssh_git_diff and ssh_git_status through the verb 'log', it does not explicitly contrast its use case.

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 vs alternatives (e.g., ssh_git_diff, ssh_git_status). The description lacks prerequisites, context, or exclusions.

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

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

With no annotations, the description effectively communicates that this is a read-only operation that fetches repository status. It does not disclose potential side effects or dependencies like git installation, but the 'status' intent is clear.

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

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

The description is concise, using a brief purpose statement followed by parameter definitions. It avoids redundancy, though the return description could be integrated more tightly. Still, every line serves a 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?

The description covers purpose and parameters adequately for a simple tool. However, it lacks details on the return value format (e.g., whether it's a string, list, or structured object), which may hinder an agent's ability to parse the output reliably.

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%, but the description provides clear, actionable details for both parameters: 'cwd' is the git repo path with default behavior, and 'host' is an SSH alias with default. This adds significant value 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?

The description clearly states the tool retrieves git status from a remote server, and specifies the exact information returned (branch, modified, staged, untracked files). It is distinct from sibling tools like ssh_git_diff and ssh_git_log.

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 by naming the returned data, but does not explicitly state when to use this tool over alternatives or provide any exclusion criteria. It lacks guidance on prerequisites or conditions.

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

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

No annotations provided, so description carries full burden. It discloses returning matching lines with file paths and line numbers, but does not mention SSH dependencies, performance implications, error handling, or scope (current directory default). Adequate but not thorough.

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

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

The description is a single concise paragraph followed by a well-structured args list. Every sentence adds value; no fluff. Front-loaded with the main 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?

With 7 parameters, no output schema, and no annotations, the description reasonably covers each parameter's role. Missing aspects like return format details (already stated), error behavior, and default values for path/glob/max_results. Acceptably complete for a search 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%, and the description compensates by explaining each parameter: pattern (RE), path (directory/file), glob (filter pattern), max_results, context_lines, case_insensitive, host (from config). These add meaning beyond schema types and defaults, though some descriptions are minimal.

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 'Search for a pattern in files on the remote server using grep' with a clear verb and resource. It distinguishes from siblings like ssh_find_files (finds by name) and ssh_read_file (reads entire files).

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

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

No explicit guidance on when to use this tool vs alternatives. Usage is implied from the description (pattern-based search), but no exclusions or context for sibling comparisons.

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?

Discloses operational detail (uses sed, only new content sent) but does not address error handling, permission requirements, or behavior for invalid line numbers. No annotations provided, so description carries full burden.

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

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

Concise and well-structured: brief operational summary followed by clear parameter list. No unnecessary words.

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

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

Covers mechanism and parameters well. Lacks return value or error behavior, but for a simple insertion tool, this is adequate given parameter thoroughness.

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%, but description explains all parameters: path, after_line (1-based, 0 for beginning), content, host (optional with default). Adds crucial context beyond 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?

Clearly states verb (insert), resource (file on remote server), and insertion point (after a specific line number). Distinguishes from sibling tools like ssh_append_file and ssh_replace_lines.

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?

Hints at efficiency (no full-file transfer) but does not explicitly guide when to use vs alternatives or mention when not to use. Lacks clear differentiation from 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?

The description explains what the tool does but lacks detail on behavioral traits such as whether it blocks, poll frequency, or error handling. No annotations are provided to supplement this.

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 a clear purpose sentence followed by an Args section, front-loading important information without extraneous text.

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

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

Given the absence of output schema and schema descriptions, the description covers input parameters well. It could specify the output format (status and output structure) for greater completeness.

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

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

With 0% schema description coverage, the description fully explains each parameter: job_id's source, tail_lines' meaning, and host's alias usage, adding significant value 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?

The description clearly states 'Check the status of a background job and retrieve its output,' specifying the verb and resource. It distinguishes from sibling tools like ssh_run_background, which starts jobs.

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 indicates that it should be used after ssh_run_background by referencing the job_id it returns. However, it does not explicitly mention when not to use it or alternative tools.

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

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

No annotations are provided, so the description carries the full burden. It mentions that max_entries prevents overwhelming output and that host uses a default, which adds some behavioral context. However, it omits details on error handling, return format, or what happens if the directory does not exist.

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 concise and well-structured, with a one-line summary followed by clear parameter explanations. Every sentence adds value, with no redundant or irrelevant 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?

Given the lack of output schema and annotations, the description is incomplete. It does not describe the return value (e.g., list of file names) or error behaviors. The parameter explanations are thorough, but missing output details reduces overall completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It fully explains all 5 parameters, including defaults (e.g., path defaults to '.'), examples for pattern (e.g., '*.py'), and rationale for max_entries (prevents overwhelming output). This adds significant meaning beyond the schema's type definitions.

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 it lists directory contents on a remote server with a specific verb ('list') and resource. It is distinguishable from siblings like ssh_read_file (reads file content) or ssh_find_files (searches files), but does not explicitly differentiate itself.

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

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

The description implies usage for listing directory contents, but it does not provide explicit guidance on when to use this tool versus alternatives (e.g., ssh_find_files). The context signals include sibling tools, but the description itself lacks when-not-to-use or alternative recommendations.

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. It explains the `parents` parameter (behaving like mkdir -p) and the `host` parameter (defaults from config), but does not disclose what happens if the directory already exists, error conditions, or whether the operation is atomic.

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 two sentences total and an Args section. Every sentence adds value, and the purpose is front-loaded. No unnecessary information.

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

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

For a simple tool with 3 parameters and no output schema, the description covers the core behavior and parameters. It could mention the return value (if any) and error handling, but it is fairly complete given the tool's 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 coverage is 0%, so the description must add meaning. It explains each parameter: path as 'Directory path to create', parents as 'create parent directories as needed (mkdir -p)', and host as 'SSH host alias from config. Uses default if omitted.' This goes beyond the schema's types 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 clearly states the tool's purpose: 'Create a directory on the remote server.' It uses a specific verb ('create') and resource ('directory on remote server'), distinguishing it from sibling tools like ssh_read_file or ssh_delete.

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?

While the purpose is clear, the description does not explicitly state when to use this tool versus alternatives, nor does it provide prerequisites or exclusions. The usage is implied by the name and purpose, but lacks 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?

The description only says 'Move or rename' without disclosing behavioral details such as whether it overwrites existing files, if it preserves permissions, or if it is an atomic operation. With no annotations, more transparency is needed.

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 succinct with a main sentence followed by a bulleted parameter list. It is well-structured and easy to scan, but could include more details 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 simple move operation, the description covers the basic parameters but omits context like return values, error handling, and whether it follows symlinks. With no output schema, these details would help the agent fully understand the tool's 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?

The description adds basic explanations for each parameter (source: current path, dest: new path, host: SSH host alias from config, uses default if omitted). Given 0% schema coverage, this compensates somewhat but lacks specifics on path format or constraints.

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

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

The description clearly states the action ('Move or rename') and resource ('file/directory on the remote server'), making the tool's purpose immediately understandable. It distinguishes from siblings like ssh_delete and ssh_upload by specifying the move/rename operation.

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

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

The description provides no guidance on when to use this tool versus its siblings, such as ssh_cp or ssh_delete. No mention of alternatives or best practices for file relocation.

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 discloses the read-replace-write mechanism and the uniqueness constraint. With no annotations, it carries the transparency burden adequately, though it omits error handling (e.g., file not found, multiple matches).

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 efficient: two sentences for the core action, an ulterior constraint, and a clear Args list. No superfluous content.

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

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

Covers the main behavior and parameter semantics effectively. Lacks details on return values or error scenarios (e.g., if old not found), but for a patch tool this is acceptable.

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?

Despite 0% schema coverage, the description's Args section explains all four parameters: path, old (must be unique), new (replacement), and host (default if omitted), adding meaning beyond the schema.

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

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

The description clearly states 'Replace a string in a file on the remote server' and explains the read-locally-replace-write-back process, distinguishing it from sibling tools like ssh_replace_lines and ssh_write_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 specifies that the old string must appear exactly once to avoid ambiguous edits, providing a key constraint. It does not explicitly list alternatives but implies its unique placement requirement.

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 full burden. It discloses the use of sed for efficient range reading and the return format (line-numbered like `cat -n`). It does not cover error handling, but for a read operation, this is sufficient.

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 no wasted words. It uses a clear structure: a one-line purpose statement, a brief efficiency note, and a clean bulleted Args list. Every sentence adds value.

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

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

Given the tool's simplicity (4 params, no output schema, many siblings), the description adequately covers what the tool does and how to use it. It does not explain edge cases (e.g., missing file), but it is complete enough for an efficient read tool.

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

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

The input schema has 0% description coverage, but the description's Args section fully explains all four parameters: path (path description), offset (0-based, default 0), limit (max lines, default 2000), host (optional, uses default). This adds significant meaning beyond the schema.

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

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

The description clearly states the action ('Read lines') and resource ('file on the remote server'). It distinguishes itself from siblings like ssh_write_file and ssh_append_file by specifying reading behavior and efficiency with partial ranges.

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 guidance on when to use the tool ('large files are safe to read partially') and mentions default host behavior. It lacks explicit when-not-to-use or alternative tools, but the context of efficient partial reading 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 provided, so the description carries the full burden. It discloses that it uses sed on the remote and that empty content deletes lines. However, it does not mention error handling (e.g., file not found, invalid line numbers), permissions, or side effects. This leaves important behavioral gaps for a mutation tool.

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

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

The description is concise with a clear main sentence, a behavioral detail sentence, and an Args list. Every sentence adds value. However, the Args list repeats information already in the schema titles; a more structured format could improve scannability.

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

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

Given no output schema, the description should mention what the tool returns (e.g., success message, modified content, or error details). It also lacks details about required permissions or edge cases (e.g., start_line > end_line). These gaps make it less complete for an agent to use confidently.

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

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

Schema coverage is 0%, so the description must clarify parameter meaning. It explicitly explains each parameter: path, start_line/end_line (1-based, inclusive), content (empty deletes), and host (defaults). This adds substantial value beyond the schema titles and types.

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 ('replace a range of lines') and the resource ('in a file on the remote server'). It distinguishes from sibling tools like ssh_insert_lines and ssh_write_file by specifying the operation is a range replacement, not an insert or full write.

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 some usage context (operates via sed, no full-file transfer) but does not explicitly state when to use this tool versus siblings like ssh_insert_lines or ssh_write_file. The guidance is implicit rather than explicit, which may leave an AI agent uncertain about trade-offs.

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 that the command runs in a bash login shell with environment preamble and describes default behaviors for cwd, timeout, and host. However, it does not mention error handling, output capture (stdout/stderr), exit codes, or potential side effects. This is a moderate disclosure.

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 well-structured with a clear first sentence then an Args section. It is concise without unnecessary words, though slightly verbose in defining defaults (acceptable given no annotations). Front-loaded effectively.

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 4 parameters, no output schema, and 21 sibling tools, the description covers parameter meanings and defaults well but lacks specification of return values (stdout/stderr, exit codes) and guidance on when to use vs siblings. Output schema is absent, so the description should explain what the tool returns, which it does not.

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%, but the description's Args section adds significant meaning beyond the schema: it provides examples, defaults, and context for each parameter (e.g., 'command' as a shell command string, 'host' as SSH alias). This compensates well for the low 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 'Execute a shell command on the remote server' and specifies that it runs in a bash login shell with environment preamble. This distinguishes it from siblings like ssh_run_background (which likely runs in background) and ssh_check_connection.

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?

While the description gives usage tips (command examples, defaults), it does not explicitly state when to use this tool versus alternatives like ssh_run_background or when not to use it. The guidance is implied but lacks clear exclusions or context for sibling differentiation.

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?

Describes detached execution via nohup, but doesn't detail side effects, error handling, or whether output persists across sessions. Still useful given no annotations.

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

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

Front-loaded purpose, then structured Args section. Every sentence is necessary and informative. 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?

Covers main usage and behavior, but lacks mention of immediate response/return value (likely job_id) and error scenarios. Still adequate for a well-understood task.

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

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

With 0% schema coverage, the Arg section fully explains each parameter: command, cwd (defaults), job_id (auto-generated), host (uses default). Adds meaning beyond 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 clearly states purpose: 'Start a long-running command in the background on the remote server.' It distinguishes from sibling ssh_run (foreground) and references ssh_job_status for follow-up.

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?

Explicit guidance: 'Use this for commands that take more than 30 seconds (e.g., builds, test suites).' Also directs to use ssh_job_status for progress, implying not for short tasks.

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

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

No annotations provided, so description carries full burden. It discloses binary-safe and streaming behavior, but does not mention return value, error handling, overwrite behavior, or authentication needs. Partial but 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?

Concise and well-structured: one-sentence purpose, one-sentence usage guideline, then bulleted parameter list. 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?

With no output schema, the description should mention what the tool returns (e.g., success message or file info). It covers purpose, usage, and parameters but misses return value and overwrite/permissions behavior. Adequate 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 has 0% description coverage; the description compensates by listing all 4 parameters with detailed descriptions (local_path, remote_path, create_dirs, host), adding meaning beyond schema titles and types.

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?

Clearly states it uploads a local file to remote server via SFTP/scp, specifies binary-safe, and explicitly distinguishes from ssh_write_file (text/UTF-8). Uses specific verb and resource.

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

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

Explicitly says to use this for binary files that ssh_write_file cannot handle, and notes large files transfer without loading into memory. Provides clear when-to-use and 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?

The description discloses atomic write (temp file + mv) and overwrite/create behavior, adding value beyond the schema. No annotations exist, so the description carries the full burden. It does not cover error handling or auth requirements, but the provided details are helpful.

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: one sentence for purpose, one for behavior, then a clear bullet list for parameters. No unnecessary words.

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

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

The description covers the core behavior and parameter meanings, but lacks details on return value (no output schema), error handling, or idempotency. For a 4-param tool with no annotations, it is minimally adequate.

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 no descriptions (0% coverage), but the description explains each parameter: path (absolute/relative), content (text), create_dirs (create parent dirs), and host (SSH alias). This adds critical meaning that the schema lacks.

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 writes content to a file on a remote server, with atomic write behavior. It distinguishes from siblings like ssh_append_file or ssh_read_file by specifying overwrite/create behavior.

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

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

The description implies usage for writing file content but does not explicitly state when to use this over alternatives like ssh_append_file or when not to use it (e.g., for small vs large files, or when partial writes might be acceptable).

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