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 states the action ('Close') but doesn't explain what happens upon closure (e.g., whether the session is terminated gracefully, if resources are freed, or if there are side effects like killing processes). For a tool that likely involves mutation, this lack of detail is a significant gap.

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

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

The description is a single, direct sentence that front-loads the essential action without any fluff. It efficiently communicates the core purpose, making it easy for an agent to parse and understand 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?

Given the complexity of closing an interactive shell (likely a mutation with potential side effects), no annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects, usage context, or what to expect after invocation, leaving the agent under-informed for safe and effective 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?

The input schema has 100% description coverage, with the single parameter 'sessionId' clearly documented. The description doesn't add any meaning beyond what the schema provides (e.g., it doesn't clarify where to get the sessionId or its format). Given the high schema coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Close') and the resource ('an interactive shell session'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'ssh_disconnect' or 'ssh_execute', which might also involve session termination or cleanup, so it doesn't reach the highest score.

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 alternatives. It doesn't mention prerequisites (e.g., needing an active session from 'ssh_start_interactive_shell'), exclusions, or how it differs from other session-related tools like 'ssh_disconnect'. This leaves the agent with minimal context for selection.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Connect to an SSH server' implies establishing a persistent connection, but doesn't specify what happens after connection (e.g., whether it returns a connection handle, establishes a session, or just verifies connectivity). It doesn't mention authentication requirements, timeout behavior, error conditions, or what the connectionId parameter represents in practice.

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, clear sentence with zero wasted words. It's appropriately sized for a tool with comprehensive schema documentation. Every word earns its place by stating the core purpose without unnecessary elaboration.

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 connection tool with 7 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what happens after connection establishment, what the connectionId is used for, or how this tool relates to other SSH operations. The agent would need to guess about the tool's behavior and output format based solely on the schema.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no additional parameter information beyond the basic purpose. It doesn't explain relationships between parameters (e.g., that password and privateKeyPath are alternative authentication methods) or provide usage examples. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description 'Connect to an SSH server' clearly states the action (connect) and target resource (SSH server). It distinguishes from siblings like ssh_execute or ssh_copy_file by focusing on establishing a connection rather than performing operations. However, it doesn't specify how it differs from ssh_connect_with_credential, which appears to be a similar connection 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?

The description provides no guidance on when to use this tool versus alternatives. With siblings like ssh_connect_with_credential (presumably for credential-based connections) and ssh_start_interactive_shell (for interactive sessions), there's no indication of when this basic connection tool is appropriate versus those alternatives. No prerequisites or exclusions are mentioned.

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 full burden but offers minimal behavioral insight. It implies a connection operation but doesn't disclose whether this creates a persistent session, requires specific permissions, has timeout/rate limits, or what happens on failure. For a security-sensitive SSH tool, this lack of transparency is a significant gap.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and uses clear terminology. Every word earns its place without being overly terse.

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

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

For a tool that establishes SSH connections (a complex, security-sensitive operation with no output schema and no annotations), the description is incomplete. It doesn't explain what the tool returns, how connections are managed, error conditions, or integration with other SSH tools. The context demands more comprehensive guidance.

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

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

Schema description coverage is 100%, so the schema already documents both parameters fully. The description adds no additional meaning about parameters beyond implying 'credentialId' refers to saved credentials and 'connectionId' identifies the connection. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Connect') and target ('SSH server') with the specific method ('using saved credentials'), which distinguishes it from the sibling 'ssh_connect' that likely uses different authentication. However, it doesn't explicitly mention what type of connection this establishes (e.g., persistent session vs. one-time command execution).

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 alternatives like 'ssh_connect' or 'ssh_start_interactive_shell'. It doesn't mention prerequisites (e.g., needing saved credentials via 'ssh_save_credential') or typical use cases (e.g., establishing a background connection for subsequent commands).

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 states the action 'copy files' but doesn't describe what happens on failures (e.g., overwrite behavior, permission issues), whether it supports recursive copying, authentication requirements, or rate limits. For a file transfer tool with zero annotation coverage, this leaves significant behavioral gaps.

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 purpose without unnecessary words. Every part of the sentence earns its place by specifying the action, resource, and scope. There's zero waste or 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?

Given the complexity of a file copy operation with no annotations and no output schema, the description is incomplete. It doesn't address error handling, output format, or behavioral nuances like overwrite policies. For a tool that performs mutations (copying files) without safety annotations, more context is needed to guide safe and effective 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 100%, so the schema already documents all 5 parameters thoroughly. The description adds no additional parameter semantics beyond implying the tool handles both local and remote sources/targets, which is already covered in the schema's descriptions for sourceConnectionId and targetConnectionId. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb 'copy' and the resource 'files', specifying the scope as 'between local and remote servers or between remote servers'. It distinguishes the tool's purpose from siblings like ssh_execute or ssh_list_files by focusing on file transfer rather than execution or listing. However, it doesn't explicitly differentiate from potential file management siblings beyond the copy action.

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 alternatives. It doesn't mention prerequisites like needing established SSH connections, nor does it compare to other file-related tools (e.g., if ssh_file_info or ssh_list_files should be used first). There's no explicit 'when-not' or alternative tool recommendations, leaving usage context implied at best.

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 full burden for behavioral disclosure. It states the destructive action ('Delete') but doesn't cover critical aspects: whether deletion is permanent or reversible, if it affects active SSH sessions using the credential, required permissions, error conditions (e.g., invalid ID), or side effects. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding 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 a single, efficient sentence with zero waste—'Delete a saved SSH credential' directly conveys the core action and resource. It's front-loaded and appropriately sized for a simple tool, with no extraneous details. Every word earns its place, making it easy to parse quickly.

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

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

Given the tool's complexity (a destructive operation with no annotations and no output schema), the description is incomplete. It lacks information on behavioral traits (e.g., permanence, dependencies), error handling, or output expectations. While the schema covers the parameter, the description doesn't compensate for missing context about the mutation's impact, making it inadequate for safe and effective 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 100%, with the single parameter 'credentialId' fully documented in the schema as 'Credential ID to delete'. The description adds no additional meaning about the parameter beyond what the schema provides—it doesn't explain ID format, source (e.g., from 'ssh_list_credentials'), or validation rules. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the action ('Delete') and resource ('a saved SSH credential'), making the purpose immediately understandable. It distinguishes from siblings like 'ssh_list_credentials' and 'ssh_save_credential' by specifying deletion rather than listing or creation. However, it doesn't specify what constitutes a 'saved SSH credential' beyond the ID parameter, leaving some ambiguity about the resource 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing credential from 'ssh_list_credentials'), exclusions (e.g., not for active connections), or related tools like 'ssh_connect_with_credential' that might depend on saved credentials. Usage is implied only by the action name, with no explicit context 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Disconnect') but doesn't explain what happens upon disconnection (e.g., if it terminates sessions, releases resources, or has side effects), nor does it mention permissions, rate limits, or error conditions. This is a significant gap for a mutation 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 a single, efficient sentence that directly states the tool's purpose without any wasted words. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.

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

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

Given the complexity of disconnecting from an SSH server (a mutation operation), the lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like effects, errors, or return values, leaving the agent with insufficient context to use the tool safely and effectively.

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 100% description coverage, with the parameter 'connectionId' clearly documented. The description doesn't add any meaning beyond what the schema provides, such as explaining what a connection ID is or how to obtain it. Given the high schema coverage, the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Disconnect') and target resource ('from an SSH server'), providing a specific verb+resource combination. However, it doesn't explicitly distinguish this tool from sibling tools like 'ssh_close_interactive_shell', which might also involve disconnection, so it doesn't reach the highest score.

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 alternatives, such as 'ssh_close_interactive_shell' or other SSH-related tools. It lacks context about prerequisites (e.g., needing an active connection) or exclusions, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries full burden. It mentions 'working directory context' which hints at behavioral context, but doesn't disclose critical traits: whether this is a mutating operation (likely yes), authentication requirements (SSH connection needed), potential side effects (container creation/startup), or error conditions. The description is insufficient for a complex 11-parameter deployment tool.

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

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

The description is a single, efficient sentence that gets straight to the point. There's no wasted language or unnecessary elaboration. It's appropriately sized for what it communicates, though what it communicates is limited.

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 complexity (11 parameters, no annotations, no output schema), the description is inadequate. It doesn't explain the deployment workflow, what happens after deployment, error handling, or the relationship between parameters. For a Docker deployment tool with SSH integration, more context about the deployment process and expected outcomes is needed.

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

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

Schema description coverage is 100%, providing good documentation for all 11 parameters. The description adds minimal value beyond the schema - 'working directory context' relates to the workingDirectory parameter but doesn't explain its significance or how it interacts with other parameters. With high schema coverage, the baseline 3 is appropriate.

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

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

The description 'Deploy Docker containers with working directory context' states the general action (deploy) and resource (Docker containers) but is vague about the specific deployment methods. It mentions 'working directory context' which hints at directory-based deployment but doesn't specify the three deployment types (compose, build, run) or distinguish this tool from sibling tools like ssh_docker_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 guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing an SSH connection), when to choose compose vs build vs run, or how it relates to sibling tools like ssh_docker_status. Usage is implied through parameter names but not explicitly stated.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It states 'Check' which implies a read-only operation, but doesn't confirm if it's safe or has side effects. It lacks details on what 'status' includes (e.g., running/stopped containers), error handling, or output format. For a tool with no annotations, this leaves significant behavioral gaps.

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 zero waste. It's front-loaded with the core purpose and includes necessary context ('in working directory'). Every word earns its place, making it easy to parse quickly.

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

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

Given no annotations and no output schema, the description is incomplete for a tool that interacts with Docker via SSH. It doesn't explain what 'status' entails, potential errors, or return values. For a tool with 2 parameters and complex context (SSH + Docker), more detail is needed to guide effective 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 100%, so the schema fully documents both parameters (connectionId and workingDirectory). The description adds no parameter-specific information beyond implying that workingDirectory relates to where Docker containers are checked. Since the schema handles the heavy lifting, the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Check') and resource ('Docker container status'), with the specific context 'in working directory' providing scope. It distinguishes from siblings like ssh_docker_deploy (which deploys rather than checks) and ssh_execute (which runs commands generally). However, it doesn't explicitly differentiate from all siblings, such as ssh_file_info which also inspects status in a directory.

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 alternatives. It doesn't mention prerequisites (e.g., needing an SSH connection first), exclusions, or comparisons to siblings like ssh_execute (which could run 'docker ps' manually). The context 'in working directory' implies a location constraint but offers no explicit usage rules.

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 full burden for behavioral disclosure. It states what the tool does but lacks critical behavioral details: no mention of execution context (e.g., synchronous vs. asynchronous), error handling, output format, timeout behavior, or security implications. This is a significant gap for a command execution tool.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded with the core functionality.

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 complexity of SSH command execution and the absence of both annotations and output schema, the description is insufficient. It doesn't address execution behavior, output handling, error conditions, or dependencies on other tools (like ssh_connect). For a potentially destructive operation with no structured safety hints, this leaves critical gaps.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (connectionId, command, cwd) with clear descriptions. The description adds no additional parameter semantics beyond what's in the schema, maintaining the baseline score for high schema coverage.

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

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

The description clearly states the action ('Execute a command') and target ('on a remote SSH server'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like ssh_start_interactive_shell or ssh_send_input, which also involve command execution in different contexts.

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 alternatives. There's no mention of prerequisites (like requiring an established SSH connection via ssh_connect), nor does it clarify when this is preferred over interactive shell tools or file operations.

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 states it 'gets' information, implying a read-only operation, but doesn't clarify permissions needed, error handling (e.g., for non-existent files), output format, or whether it works for remote vs. local files (hinted in schema but not description). For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 a single, efficient sentence with zero waste. It front-loads the core action ('Get file information') and adds useful detail ('size, permissions, etc.') without unnecessary elaboration. Every word earns its place, making it highly 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?

Given the tool's moderate complexity (file operations over SSH), lack of annotations, and no output schema, the description is incomplete. It doesn't explain the return values, error conditions, or dependencies on other tools (e.g., ssh_connect). While the schema covers parameters well, the description fails to provide sufficient context for safe and effective use in this environment.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters (connectionId and filePath). The description adds no additional parameter semantics beyond what the schema provides, such as examples or constraints. With high schema coverage, the baseline score of 3 is appropriate, as the schema does the heavy lifting without extra value from 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 clearly states the verb 'Get' and the resource 'file information', specifying what attributes are retrieved (size, permissions, etc.). It distinguishes from siblings like ssh_list_files (which lists files) and ssh_execute (which runs commands), but doesn't explicitly name alternatives. The purpose is specific and actionable, though sibling differentiation is implicit 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an established SSH connection via ssh_connect), exclusions, or compare it to similar tools like ssh_list_files for directory contents. Usage is implied by the tool name and context, but no explicit guidelines are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't add context beyond that—for example, it doesn't mention if this is a read-only operation, what permissions are required, how it handles errors, or what the output format might be. This leaves significant gaps in understanding the tool's 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 a single, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized and front-loaded, making it easy to understand at a glance.

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 complexity of SSH operations and the lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., a string path), potential errors, or dependencies like requiring an active connection, leaving the agent with insufficient context for reliable 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?

The input schema has 100% description coverage, with the single parameter 'connectionId' clearly documented. The description doesn't add any extra meaning or details about the parameter beyond what the schema provides, so it meets the baseline of 3 for adequate but not enhanced parameter semantics.

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

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

The description clearly states the verb 'Get' and the resource 'current working directory for a connection', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'ssh_set_working_directory' beyond the obvious 'get' vs 'set' distinction, which is why it doesn't earn a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when to prefer this over other directory-related operations or in what context it's most useful. It lacks any mention of prerequisites, exclusions, or related tools, leaving usage entirely implicit.

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 states what the tool does but doesn't describe how it behaves: it doesn't mention output format (e.g., list structure, credential details), potential errors (e.g., if no credentials exist), or security implications (e.g., whether passwords are masked). This leaves significant gaps for a tool handling sensitive 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?

The description is a single, efficient sentence that directly states the tool's purpose with no unnecessary words. It's front-loaded and perfectly sized for a simple list operation.

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 complexity (handling sensitive SSH credentials) and the lack of annotations and output schema, the description is incomplete. It doesn't explain what information is returned (e.g., credential names, hosts, usernames), how to interpret the output, or any behavioral nuances, leaving the agent with insufficient context.

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

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

The tool has zero parameters, and schema description coverage is 100%, so there's no need for parameter documentation in the description. The baseline for zero parameters is 4, as the description appropriately doesn't waste space on non-existent parameters.

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

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

The description clearly states the verb ('List') and resource ('all saved SSH credentials'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'ssh_save_credential' or 'ssh_delete_credential' beyond the obvious list vs. modify distinction, which prevents a perfect score.

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 alternatives. It doesn't mention prerequisites (e.g., needing saved credentials first), related tools like 'ssh_connect_with_credential', or scenarios where listing credentials is appropriate versus directly connecting.

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 for behavioral disclosure. It mentions the action ('List') but doesn't cover critical aspects like permissions needed, error handling (e.g., for invalid paths), output format, or whether it's a read-only operation. This is a significant gap for a tool that interacts with file systems.

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 purpose without unnecessary words. Every part earns its place by specifying the action, resource, and scope concisely.

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 annotations and no output schema, the description is incomplete. It doesn't explain what the output looks like (e.g., list format, error responses), behavioral traits like safety or permissions, or how it differs from siblings. For a file-listing tool in an SSH context, this leaves too many gaps for effective agent 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 100%, so the schema already documents all parameters fully. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't clarify path formats or connectionId usage). Baseline 3 is appropriate as the schema handles parameter documentation adequately.

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 verb ('List') and resource ('files and directories'), and specifies the scope ('on local or remote server'), which is helpful. However, it doesn't explicitly differentiate from sibling tools like 'ssh_file_info' (which might get metadata for a single file) or 'ssh_get_working_directory' (which might list the current directory), so it misses full sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'ssh_file_info' for single-file details or 'ssh_get_working_directory' for current directory listing. It lacks explicit when/when-not instructions or named alternatives, leaving usage context implied at best.

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 states what the tool does but doesn't describe key behaviors: whether this is a read-only operation, if it blocks until output is available, what happens on timeout, or the format of returned output. For a tool with no annotations, this leaves significant gaps in understanding its 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 a single, clear sentence that front-loads the essential action ('Read output'). There's no wasted verbiage or redundancy, making it highly efficient and easy to parse quickly.

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

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

Given the complexity of interactive shell operations and the lack of annotations and output schema, the description is incomplete. It doesn't explain what the output looks like (e.g., text, error handling), how it interacts with session state, or prerequisites like needing an active session. For a tool with no structured output information, more context is needed to be fully helpful.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description doesn't add any additional meaning beyond what's in the schema (e.g., it doesn't explain how sessionId relates to interactive sessions or clarify timeout behavior). With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but doesn't detract either.

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 verb ('Read') and resource ('output from an interactive shell session'), making the purpose immediately understandable. It distinguishes from siblings like ssh_send_input (which sends input) and ssh_execute (which executes commands non-interactively). However, it doesn't specify that this reads from an existing session rather than creating one, which could be more 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?

The description implies usage by mentioning 'interactive shell session', suggesting it should be used after starting a session with ssh_start_interactive_shell. However, it doesn't explicitly state when to use this vs. alternatives like ssh_execute (for non-interactive output) or provide clear exclusions. The context is somewhat implied but lacks direct 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 full burden for behavioral disclosure. 'Save SSH credentials for reuse' implies persistence and security implications, but doesn't disclose where credentials are stored (local vs remote), encryption methods, access controls, expiration policies, or error handling. For a credential management tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that directly states the tool's purpose. It's appropriately sized and front-loaded with zero wasted words, making it easy for an AI agent to parse quickly.

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

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

For a credential storage tool with 7 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what happens after saving (e.g., how credentials are retrieved/used), security implications, storage location, or success/failure responses. The context demands more completeness for safe and effective 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 100%, providing complete parameter documentation. The description adds no parameter-specific information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in 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 'Save SSH credentials for reuse' clearly states the action (save) and resource (SSH credentials) with the purpose of enabling reuse. It distinguishes from siblings like 'ssh_delete_credential' (deletion) and 'ssh_list_credentials' (listing), but doesn't explicitly differentiate from 'ssh_connect_with_credential' which uses saved credentials.

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 alternatives. It doesn't mention prerequisites (e.g., needing credentials first), when not to use it (e.g., for temporary connections), or how it relates to siblings like 'ssh_connect' (direct connection) or 'ssh_connect_with_credential' (using saved credentials).

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

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

With no annotations, the description carries full burden. It mentions 'typing simulation' as an optional behavior, which adds some context, but doesn't disclose critical traits like whether this is a read-only or destructive operation, potential side effects, error handling, or response format. For a tool that sends input to a shell (potentially affecting system state), this is a significant gap.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Send input to an interactive shell session') and adds an optional feature ('with optional typing simulation'). Every word earns its place with no redundancy or fluff.

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 annotations and no output schema, the description is incomplete for a tool that interacts with shell sessions. It doesn't explain what happens after sending input (e.g., how to read output with ssh_read_output), error conditions, or behavioral implications. For a 3-parameter tool with potential system impact, more context is needed.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds minimal value beyond the schema by hinting at the purpose of 'simulateTyping' but doesn't provide additional syntax, format, or usage details. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Send input') and target ('to an interactive shell session'), distinguishing it from sibling tools like ssh_execute (non-interactive) and ssh_read_output (receiving output). It specifies the interactive nature, which is a key differentiator.

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 interactive sessions but doesn't explicitly state when to use this vs. alternatives like ssh_execute for non-interactive commands or prerequisites like needing an active session from ssh_start_interactive_shell. It provides some context but lacks explicit guidance on alternatives 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 provided, the description carries the full burden of behavioral disclosure. It states the tool sets a working directory but lacks critical details: whether this requires specific permissions, if the change is persistent across sessions, what happens on invalid paths, or if it affects all users on the connection. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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 directly states the tool's function without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every part of the sentence earns its place by conveying 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?

Given the tool's mutation nature, lack of annotations, and absence of an output schema, the description is incomplete. It doesn't explain what happens after setting the directory (e.g., success confirmation, error handling, or effects on other operations). For a tool that modifies state in an SSH context, more context about behavioral outcomes is needed to be fully helpful.

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

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

Schema description coverage is 100%, with both parameters ('connectionId' and 'workingDirectory') clearly documented in the schema. The description adds no additional semantic context beyond implying these parameters are used to set the directory. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't compensate with extra details like path format examples or connection state requirements.

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 ('Set') and target ('current working directory for a connection'), making the purpose immediately understandable. It distinguishes from siblings like 'ssh_get_working_directory' by specifying the set operation rather than retrieval. However, it doesn't explicitly mention the SSH context beyond the tool name, which slightly limits specificity.

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 alternatives. It doesn't mention prerequisites like needing an established SSH connection, nor does it differentiate from similar operations in sibling tools. For example, it doesn't clarify if this affects subsequent 'ssh_execute' commands or how it relates to 'ssh_start_interactive_shell'.

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 full burden but offers minimal behavioral insight. It mentions 'PTY support for typing simulation' which hints at interactive capabilities, but fails to disclose critical traits: whether this spawns a persistent session, requires specific permissions, has rate limits, or how output/input are handled (e.g., via ssh_read_output/ssh_send_input). For a complex interactive tool, this is inadequate.

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 purpose without fluff. Every word earns its place, making it easy to parse quickly. No structural issues or redundancy are present.

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

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

For a complex interactive tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral expectations (e.g., session lifecycle, interaction patterns), error handling, or integration with sibling tools like ssh_send_input. Given the context, it should provide more operational guidance.

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

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

Schema description coverage is 100%, providing clear documentation for all 5 parameters. The description adds no additional parameter semantics beyond what the schema already states (e.g., it doesn't explain how sessionId is used or PTY relates to cols/rows). Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('Start an interactive shell session') and the resource ('with PTY support for typing simulation'), making the purpose evident. It distinguishes from siblings like ssh_execute (non-interactive) and ssh_connect (connection only), but doesn't explicitly name alternatives. A 5 would require explicit sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives like ssh_execute for non-interactive commands. It doesn't mention prerequisites (e.g., requiring an established SSH connection via ssh_connect), exclusions, or contextual triggers. Usage is implied but not articulated.

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