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 output is lost, or if it requires specific permissions). This is a significant gap for a tool that likely involves session management.

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 front-loaded and wastes no space, 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 complexity of session management and the lack of annotations or output schema, the description is incomplete. It doesn't cover behavioral aspects like side effects, error conditions, or what happens post-closure, which are crucial for an AI agent to use this tool correctly in 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?

Schema description coverage is 100%, with the single parameter 'sessionId' well-documented in the schema. The description doesn't add any meaning beyond this (e.g., how to obtain the sessionId or format requirements), so it meets the baseline of 3 where 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 ('close') and resource ('interactive shell session'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'ssh_disconnect' (which might close connections rather than specific shell sessions), leaving some ambiguity about when to use each.

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_disconnect' or 'ssh_execute' for ending sessions. It mentions the resource but doesn't specify prerequisites (e.g., must have an active shell session) or exclusions, leaving usage context unclear.

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. 'Connect to an SSH server' implies establishing a network connection but reveals nothing about authentication requirements, timeout behavior, connection persistence, error handling, or what happens after connection. For a security-sensitive tool with 7 parameters, 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 maximally concise with a single clear sentence that states the core purpose. There's no wasted language or unnecessary elaboration, making it easy to parse and 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?

For a complex SSH connection tool with 7 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what happens after connection, how to manage the connection, what errors might occur, or how this differs from sibling connection tools. The agent lacks critical context for proper tool selection and invocation.

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

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

Schema description coverage is 100%, with all 7 parameters well-documented in the schema itself. The description adds no additional parameter information beyond what's already in the structured schema, so it meets the baseline for high schema coverage without adding 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 action ('connect') and target ('SSH server'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from its sibling 'ssh_connect_with_credential', which appears to serve a similar purpose with different authentication methods.

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' and 'ssh_disconnect', there's no indication of when this specific connection method is preferred or what prerequisites exist for successful connection.

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 tool establishes an SSH connection but lacks critical details: whether this initiates an interactive session, requires specific permissions, has side effects (e.g., opening network ports), or handles errors. For a connection 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 front-loads the core purpose without unnecessary words. Every part ('Connect to SSH server using saved credentials') earns its place by specifying the action and method, making it appropriately concise and well-structured.

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

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

Given the complexity of SSH operations (involving network connections, authentication, and potential side effects), no annotations, and no output schema, the description is incomplete. It doesn't explain what happens after connection (e.g., returns a session handle, initiates a shell), error conditions, or dependencies on other tools like 'ssh_save_credential'. This leaves the agent with insufficient context 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 both parameters ('credentialId' and 'connectionId') clearly documented in the schema. The description adds no additional parameter semantics beyond implying the use of saved credentials, which aligns with the schema. This meets the baseline score of 3 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 ('Connect to SSH server') and the method ('using saved credentials'), which provides a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'ssh_connect' (which likely uses different authentication methods) or 'ssh_start_interactive_shell' (which might be for different connection types).

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 via 'ssh_save_credential'), exclusions, or comparisons to siblings like 'ssh_connect' (which might use direct credentials). This leaves the agent with minimal context for tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action 'copy files' but doesn't mention critical behaviors: whether it overwrites existing files, handles permissions, supports recursive copying, provides progress feedback, or has rate limits. This is inadequate for a file operation 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 with zero wasted words. It's front-loaded with the core purpose and avoids unnecessary elaboration, 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?

For a file copy operation with no annotations and no output schema, the description is incomplete. It lacks behavioral details (overwrite behavior, error handling), usage context (prerequisites like active connections), and output expectations. This leaves significant gaps for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, so the schema fully documents all 5 parameters. The description adds no additional parameter semantics beyond implying directionality (local/remote), which is already covered by parameter descriptions. 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 verb 'copy' and the resource 'files', specifying the directionality 'between local and remote servers or between remote servers'. This distinguishes it from sibling tools like ssh_list_files (list) or ssh_execute (execute commands).

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing established SSH connections), exclusions, or comparisons to similar tools like ssh_file_info for checking file existence before copying.

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 ('Delete') but lacks critical details: whether this is irreversible, if it affects active SSH sessions, what permissions are required, or what happens on success/failure. For a destructive operation, this omission is significant and limits safe usage.

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 with zero wasted words. It front-loads the key action ('Delete') and resource, making it easy to parse. Every word earns its place, achieving optimal conciseness for a simple tool.

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

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

Given the tool's destructive nature and lack of annotations or output schema, the description is incomplete. It doesn't address behavioral risks, error conditions, or return values, leaving gaps for safe invocation. For a delete operation with no structured safety hints, more context is needed to ensure proper 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 schema has 100% description coverage, with the parameter 'credentialId' clearly documented in the schema itself. The description adds no additional meaning beyond the schema, such as how to obtain the ID or format requirements. Baseline 3 is appropriate since the schema adequately covers 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 ('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 focusing on deletion rather than listing or creation. However, it doesn't specify the scope (e.g., from local storage or a remote system), 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 an existing credential), exclusions (e.g., not for active connections), or related tools like 'ssh_list_credentials' for identifying IDs. Without such context, an agent must 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but lacks details on effects (e.g., whether it terminates all sessions, requires specific permissions, or handles errors). This is a significant gap for a tool that likely involves network operations.

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 with zero wasted words, making it highly efficient and front-loaded. It immediately conveys 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?

Given the complexity of SSH operations and lack of annotations or output schema, the description is insufficient. It doesn't cover behavioral aspects like side effects, error handling, or return values, leaving gaps for safe and effective tool invocation.

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

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

The input schema has 100% description coverage, documenting the 'connectionId' parameter clearly. The description adds no additional meaning beyond what the schema provides, so it meets the baseline for high schema coverage without compensating 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 action ('Disconnect') and target resource ('from an SSH server'), making the purpose immediately understandable. It doesn't differentiate from sibling tools like 'ssh_close_interactive_shell', which might handle a specific type of disconnection, so it misses the top 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?

No guidance is provided on when to use this tool versus alternatives such as 'ssh_close_interactive_shell' or in what context disconnection is appropriate. The description assumes usage without specifying prerequisites or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'working directory context' but fails to detail critical behaviors: it doesn't specify if this is a read-only or destructive operation (likely destructive as it deploys containers), what happens on failure, or any side effects like network changes. For a complex deployment tool with 11 parameters, 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 gets straight to the point without fluff. It's front-loaded with the core action ('Deploy Docker containers') and includes a key constraint. However, it could be more structured by explicitly mentioning the three deployment types or linking to sibling tools, but it avoids wastefulness.

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 insufficient. It doesn't cover behavioral aspects like error handling, output format, or prerequisites (e.g., SSH connection setup). For a deployment tool that likely involves mutations and side effects, more context is needed to guide the agent effectively, making it incomplete.

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

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

Schema description coverage is 100%, so the schema already documents all 11 parameters thoroughly. The description adds minimal value beyond the schema—it hints at the 'workingDirectory' parameter's role but doesn't explain parameter interactions (e.g., how deploymentType affects other params). Baseline 3 is appropriate as the schema does the heavy lifting, though the description could have clarified dependencies.

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 Docker containers) and mentions a key constraint (working directory context), but it's vague about what 'deploy' entails—it could mean building, running, or composing. It doesn't clearly distinguish from sibling tools like ssh_docker_status, which monitors containers, leaving ambiguity about its specific role.

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 is provided on when to use this tool versus alternatives. While the description implies it's for Docker deployments, it doesn't specify prerequisites (e.g., needing an SSH connection first) or contrast with siblings like ssh_execute for general commands. The lack of when-to-use or when-not-to-use statements leaves the agent to infer context from parameters 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 checking status but doesn't disclose behavioral traits such as what 'status' includes (e.g., running/stopped containers, logs), whether it's read-only (implied by 'check'), error handling, or output format. For a tool with no 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 directly states the tool's purpose without redundancy. It's appropriately sized for a simple tool and front-loaded with the core action, 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, no output schema, and a simple input schema, the description is incomplete. It doesn't explain what the tool returns (e.g., container list, status codes), error conditions, or dependencies (e.g., requires Docker installed). For a tool interacting with Docker via SSH, more context is needed to use it 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?

Schema description coverage is 100%, so the schema fully documents both parameters (connectionId and workingDirectory). The description adds minimal value beyond the schema by implying the working directory context but doesn't provide additional syntax, format details, or usage examples. Baseline 3 is appropriate as the schema handles parameter documentation.

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'), specifying the scope ('in working directory'). It distinguishes from siblings like ssh_docker_deploy (deploy vs. check) and ssh_execute (general execution vs. specific Docker check). However, it doesn't explicitly differentiate from all siblings (e.g., ssh_file_info also checks status but for files).

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

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

The description provides minimal guidance, implying usage when needing to check Docker container status in a working directory via SSH. It lacks explicit when-to-use scenarios, prerequisites (e.g., requires an active SSH connection), or alternatives (e.g., vs. ssh_execute for custom Docker commands). No exclusions or comparisons to siblings 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, the description carries full burden but provides minimal behavioral details. It states what the tool does but doesn't disclose critical traits like whether it's read-only or destructive, authentication requirements, error handling, or output format (e.g., stdout/stderr). This leaves significant gaps for safe and effective use.

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 and wastes no space, 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 complexity of SSH command execution (involving connections, commands, and potential side effects), no annotations, and no output schema, the description is incomplete. It lacks details on prerequisites, safety, or what to expect in return, which are crucial for this type of 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 100%, so the schema fully documents parameters like 'connectionId' and 'command'. The description adds no additional meaning beyond implying execution context, meeting the baseline for high coverage without extra 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 action ('Execute a command') and target ('on a remote SSH server'), making the purpose immediately understandable. It doesn't differentiate from siblings like ssh_start_interactive_shell or ssh_send_input, which are related but distinct operations, so it misses 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?

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention prerequisites like needing an established SSH connection (via ssh_connect) or when to prefer interactive shells (ssh_start_interactive_shell) over command execution. The description assumes context without stating it.

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

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

With no annotations, the description carries full burden but provides minimal behavioral context. It mentions what information is retrieved but doesn't cover error handling, permissions needed, whether it's read-only (implied by 'Get'), or output format. This leaves gaps for a tool interacting with remote 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 with zero waste. It's front-loaded with the core purpose and includes relevant examples (size, permissions), making it appropriately sized for its function.

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 the return values (e.g., format of file info), error cases, or dependencies on SSH connections, which are critical for a tool in this context with siblings involving remote operations.

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 parameters are well-documented in the schema. The description adds no additional meaning beyond implying the tool retrieves metadata for a file, which aligns with but doesn't enhance the schema's details on connectionId and filePath.

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 attributes like size and permissions. It distinguishes from siblings like ssh_list_files (which lists files) and ssh_read_output (which reads file content), but doesn't explicitly name alternatives or contrast scope.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an SSH connection first), exclusions, or compare with similar tools like ssh_list_files for metadata at scale.

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. While 'Get' implies a read-only operation, it doesn't specify whether this requires active connection status, what happens if the connection is invalid, or what format the directory path returns. For a 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 communicates the core purpose without any wasted words. It's appropriately sized for a simple tool and gets straight to the point with clear subject-verb-object structure.

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

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

For a simple read operation with one well-documented parameter and no output schema, the description is minimally adequate. However, it doesn't address connection state requirements or return format, which would be helpful given the lack of annotations. The description meets basic requirements but could provide more context about the tool's behavior and output.

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 'connectionId' clearly documented in the schema. The description doesn't add any additional parameter context beyond what the schema already provides, so the baseline score 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 clearly states the verb 'Get' and the resource 'current working directory for a connection', making the purpose immediately understandable. It doesn't explicitly distinguish from sibling tools like 'ssh_set_working_directory', but the 'Get' vs 'Set' distinction is implied through contrasting verbs.

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 clarify relationships with sibling tools such as 'ssh_set_working_directory' or 'ssh_execute' which might affect or depend on the working directory.

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 ('List') but doesn't describe what 'saved SSH credentials' entails (e.g., format, scope like user/system-wide), potential side effects (e.g., if listing exposes sensitive data), or output behavior (e.g., pagination, error handling). For a tool with zero annotation coverage, this leaves significant 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 ('List all saved SSH credentials') that directly conveys the core functionality without any wasted words. It is appropriately sized and front-loaded, 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 low complexity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior, output format, or usage context. For a simple list operation, this might suffice, but it doesn't provide a complete picture for an agent to use it effectively without additional assumptions.

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 parameters with 100% coverage, so the schema fully documents the absence of inputs. The description doesn't need to add parameter details, and it correctly implies no parameters are required by not mentioning any. This meets the baseline for tools with no 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 'List all saved SSH credentials' clearly states the verb ('List') and resource ('saved SSH credentials'), making the tool's purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'ssh_save_credential' or 'ssh_delete_credential' beyond the obvious action difference, which is why it doesn't reach 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), compare it to similar tools like 'ssh_connect' (which might list active connections), or specify use cases (e.g., credential management vs. connection establishment).

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 reveals little about behavior. It doesn't disclose what permissions are needed, whether it's read-only (implied but not stated), what format the output takes (list vs tree vs details), error conditions, or rate limits. The mention of 'local or remote' is helpful context but insufficient for a mutation-free 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 with zero waste. It's front-loaded with the core purpose and includes the key scope detail ('local or remote server'). Every word earns its place.

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

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

For a tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the output looks like (file list format, metadata included), error behavior, or dependencies on other tools (like ssh_connect). Given the sibling tool complexity, more context about when this is the right choice would be valuable.

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 three parameters. The description adds no additional parameter semantics beyond what's in the schema (like explaining 'local' special value for connectionId or path conventions). 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 verb 'list' and the resources 'files and directories', and specifies the scope 'on local or remote server'. However, it doesn't explicitly differentiate from sibling tools like ssh_file_info (which gets metadata for a specific file) or ssh_execute (which could also list files via 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. It doesn't mention prerequisites (like needing an established SSH connection first), nor does it compare to sibling tools like ssh_execute (which could run 'ls' commands) or ssh_file_info (for single file details).

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions reading output but doesn't disclose what happens on timeout, how output is formatted, whether it's blocking/non-blocking, or error conditions. This is inadequate for a tool that interacts with live shell sessions.

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 appropriately sized and front-loaded with the core purpose.

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

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

For a tool that reads from interactive sessions with no annotations and no output schema, the description is insufficient. It doesn't explain return values, error handling, or important behavioral aspects like what 'output' includes (stdout, stderr, both). More context is needed given the complexity.

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 three parameters. The description adds no additional parameter context beyond implying a session exists, which is already covered by the sessionId parameter's description. 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 ('Read output') and resource ('from an interactive shell session'), making the purpose immediately understandable. It doesn't explicitly differentiate from siblings like ssh_execute or ssh_send_input, but the focus on reading output from an existing session is reasonably distinct.

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 via ssh_start_interactive_shell), exclusions, or comparisons to non-interactive execution tools like ssh_execute.

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 states the tool saves credentials but lacks critical behavioral details: where credentials are stored (e.g., in-memory, file, database), security implications (e.g., encryption, persistence), whether it overwrites existing credentials with the same ID, or what happens on success/failure. This is inadequate 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 with no wasted words. It's front-loaded with the core purpose, making it easy to parse quickly. Every word earns its place by conveying the essential action and resource.

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 handles sensitive SSH credentials. It misses key context: storage method, security behavior, interaction with sibling tools (e.g., ssh_list_credentials), and what 'reuse' entails. For a 7-parameter mutation tool, this leaves significant 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 fully documents all 7 parameters. The description adds no parameter-specific information beyond implying credential persistence. Baseline 3 is appropriate since the schema handles parameter semantics, though the description doesn't compensate for any gaps (none exist).

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 ('Save') and resource ('SSH credentials for reuse'), making the purpose understandable. It doesn't explicitly distinguish from siblings like ssh_delete_credential or ssh_list_credentials, but the verb 'Save' implies creation/persistence versus deletion or listing.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing to save credentials before using ssh_connect_with_credential), exclusions, or comparisons to other credential-related tools like ssh_delete_credential or ssh_list_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?

No annotations are provided, so the description carries full burden. It mentions 'optional typing simulation' which hints at behavioral traits (delays), but lacks critical details: whether this requires specific permissions, if input is buffered or immediate, error handling (e.g., invalid sessionId), or side effects (e.g., session state changes). For a tool that interacts with shell sessions, 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 with zero waste—it front-loads the core action ('Send input to an interactive shell session') and adds optional detail ('with optional typing simulation'). Every word earns its place, making it appropriately sized and well-structured for quick comprehension.

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 complexity (interactive shell interaction), no annotations, and no output schema, the description is incomplete. It doesn't explain return values (e.g., success/failure, output handling), error conditions, or dependencies on other tools like ssh_start_interactive_shell. For a tool with behavioral nuances and sibling interactions, this leaves critical gaps for an AI agent.

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 parameters (sessionId, input, simulateTyping). The description adds minimal value beyond the schema—it implies 'typing simulation' relates to simulateTyping but doesn't elaborate on delay behavior or use cases. Baseline 3 is appropriate as the schema does the heavy lifting, though no extra semantic context is provided.

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

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

The description clearly states the verb ('Send input') and resource ('to an interactive shell session'), specifying the action and target. It distinguishes from siblings like ssh_execute (non-interactive) and ssh_read_output (receiving output), though not explicitly named. However, it doesn't fully differentiate from all siblings like ssh_start_interactive_shell (initiating sessions).

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., requiring an active interactive session started via ssh_start_interactive_shell), exclusions (e.g., not for non-interactive commands), or comparisons with siblings like ssh_execute for one-off commands. Usage is implied 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Set') but lacks details on permissions required, whether changes are persistent across sessions, error handling, or side effects. This is inadequate 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 unnecessary words. It's front-loaded and wastes no space, 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 involves mutation (setting a directory) with no annotations and no output schema, the description is incomplete. It doesn't explain what happens on success/failure, return values, or behavioral nuances, which are critical for an agent to use it correctly in context with siblings.

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

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

Schema description coverage is 100%, so the schema already documents both parameters ('connectionId' and 'workingDirectory') fully. The description implies setting a directory path but adds no syntax, format, or validation details beyond what the schema provides, meeting the baseline for high 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 ('Set') and resource ('current working directory for a connection'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'ssh_get_working_directory' or 'ssh_execute' which might also involve directory operations, missing 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. It doesn't mention prerequisites (e.g., needing an active SSH connection), exclusions, or compare to siblings like 'ssh_get_working_directory' for retrieval or 'ssh_execute' for commands in a directory, leaving usage context unclear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'PTY support for typing simulation,' hinting at interactive capabilities, but fails to describe critical behaviors such as session lifecycle management, how output is handled (e.g., via ssh_read_output), or potential side effects like resource consumption. This leaves significant gaps for a tool that initiates interactive sessions.

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 ('Start an interactive shell session') and adds a key feature ('with PTY support for typing simulation') without unnecessary details. 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 complexity of starting an interactive shell session, no annotations, and no output schema, the description is incomplete. It lacks information on return values, error handling, session management dependencies (e.g., on ssh_read_output for reading output), and behavioral nuances, leaving the agent under-informed for effective tool invocation.

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

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

Schema description coverage is 100%, with each parameter clearly documented in the input schema (e.g., connectionId as 'SSH connection ID,' shell with default '/bin/bash'). The description adds no additional parameter semantics beyond implying interactive use, so it meets the baseline score of 3 where 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 ('Start an interactive shell session') and specifies key functionality ('with PTY support for typing simulation'), which distinguishes it from non-interactive execution tools like ssh_execute. However, it doesn't explicitly differentiate from all sibling tools, such as ssh_close_interactive_shell, which is related but opposite in purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives like ssh_execute for non-interactive commands or ssh_connect for establishing connections. It lacks context about prerequisites (e.g., needing an active SSH connection via connectionId) or exclusions, leaving the agent to infer usage from parameter names alone.

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