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 that logs are retrieved 'if available' which hints at conditional availability, but doesn't explain what determines availability, error conditions, or authentication requirements. The SSH execution context is mentioned in parameter descriptions but not in the main behavioral description. No information about rate limits, permissions needed, or what happens when host/username are omitted.

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 appropriately sized and well-structured. The first sentence states the purpose, followed by clear parameter explanations in a bullet-like format. Each parameter description earns its place by adding meaningful context. No redundant information or 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 tool has 3 parameters, no annotations, but has an output schema, the description is moderately complete. The parameter explanations are strong, but the behavioral context is lacking. The existence of an output schema means the description doesn't need to explain return values, but it should provide more context about the tool's operation, error conditions, and relationship to sibling tools.

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

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

The description provides excellent parameter semantics that go well beyond the input schema. With 0% schema description coverage, the description fully compensates by explaining: 'lines' controls the number of log lines retrieved with a default, 'host' enables remote SSH execution with local fallback, and 'username' is conditionally required. This adds crucial context about how parameters interact that isn't in the schema.

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

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

The description states the tool 'Get audit logs if available' which provides a basic verb+resource combination, but it's vague about what 'audit logs' specifically refer to and doesn't distinguish this from sibling tools like 'get_journal_logs' or 'get_service_logs'. It doesn't specify the source or type of audit logs being retrieved.

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 sibling tools like 'get_journal_logs' or 'get_service_logs' that might serve similar purposes, nor does it explain when audit logs would be preferred over other log types. There's no context about prerequisites or typical use cases.

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 mentions SSH connectivity for remote hosts, which adds useful context about authentication and execution method. However, it doesn't cover critical behavioral traits such as whether this is a read-only operation, potential performance impacts, error handling, or output format details. For a tool with no annotations, this leaves significant gaps in understanding how it behaves.

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 appropriately sized and front-loaded: it starts with the core purpose in the first sentence, followed by parameter details in a structured 'Args' section. There's no wasted text, and each sentence earns its place by providing essential information. It could be slightly more concise by integrating the parameter notes more seamlessly, but overall it's efficient.

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 that there is an output schema (which means the description doesn't need to explain return values) and no annotations, the description is moderately complete. It covers the purpose and parameter usage adequately. However, for a tool that interacts with system resources (potentially via SSH), it lacks details on permissions, error cases, or behavioral constraints, making it incomplete for safe and effective use by 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?

The description adds meaningful semantics beyond the input schema, which has 0% description coverage. It explains that 'host' is optional and executes locally if not provided, and that 'username' is required if host is provided. This clarifies the conditional relationship between parameters and their practical usage, compensating well for the lack of schema descriptions. With 2 parameters and low schema coverage, the description does a good job of 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 tool's purpose: 'Get CPU information and load averages.' This specifies the verb ('Get') and resource ('CPU information and load averages'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from siblings like 'get_hardware_info' or 'get_system_info', which might also provide CPU-related data, so it's not 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 implies usage guidelines by explaining that the host parameter is optional and executes locally if not provided, and that username is required if host is provided. This gives some context for when to use remote vs. local execution. However, it doesn't explicitly state when to use this tool versus alternatives like 'get_hardware_info' or 'get_system_info', nor does it provide exclusions or broader context, so it's not fully explicit.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions SSH connectivity behavior (remote vs local execution), it doesn't describe what specific filesystem usage information is returned, format of output, whether it requires special permissions, potential performance impact, or error conditions. The description provides some context but leaves significant behavioral aspects unspecified.

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 appropriately sized with a clear purpose statement followed by parameter documentation. The two-sentence structure is efficient, though the parameter documentation could be slightly more integrated with the main description rather than appearing as a separate 'Args' section.

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 that an output schema exists (which should document return values), the description doesn't need to explain return values. However, for a system monitoring tool with no annotations and 2 parameters, the description should provide more behavioral context about what specific disk usage metrics are retrieved, typical use cases, or limitations. The SSH connectivity details are helpful but insufficient for full completeness.

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

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

With 0% schema description coverage, the description must compensate for the schema's lack of parameter documentation. The description successfully adds meaningful semantics for both parameters: it explains that 'host' is optional for remote SSH connections (defaulting to local execution), and that 'username' is required conditionally based on whether host is provided. This provides crucial context beyond the bare schema.

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

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

The description clearly states the tool's purpose with specific verbs ('Get filesystem usage and mount points'), which distinguishes it from sibling tools focused on CPU, memory, network, or logs. However, it doesn't explicitly differentiate from 'list_block_devices' which might provide related but different information about storage devices.

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

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

The description implies usage context through the parameter documentation (SSH for remote hosts, local execution if no host provided), but doesn't explicitly state when to use this tool versus alternatives like 'list_block_devices' or other system monitoring tools. No explicit when-not-to-use guidance or named alternatives are provided.

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

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

No annotations are provided, so the description carries the full burden. It mentions remote execution via SSH and local fallback, which is useful behavioral context. However, it doesn't disclose critical details like authentication methods (e.g., password, key-based), error handling, performance characteristics, or what the output contains beyond the listed hardware components. 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 appropriately sized with two clear sections: a purpose statement and parameter explanations. Every sentence adds value, with no redundant information. It could be slightly more front-loaded by integrating parameter details into the main flow, but overall it's efficient 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 that there's an output schema (which should document return values), the description doesn't need to explain outputs. However, with no annotations and 0% schema description coverage, the description provides basic purpose and parameter guidance but lacks depth on behavioral aspects like error conditions, security implications of SSH usage, or performance considerations. It's minimally adequate but has clear gaps for a tool that interacts with system hardware.

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

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

The schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for both parameters: explaining that 'host' is optional for remote SSH connection (defaulting to local execution) and that 'username' is required if host is provided. This clarifies usage beyond the bare schema, though it doesn't cover all potential edge cases like port numbers or authentication details.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('hardware information'), listing specific components like CPU architecture, PCI devices, USB devices, and memory hardware. However, it doesn't explicitly differentiate from sibling tools like get_cpu_info or get_memory_info, which appear to be more specialized versions of this broader 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 implies usage through the parameter documentation in the Args section, explaining when to provide host and username for remote execution versus local execution. However, it lacks explicit guidance on when to use this tool versus alternatives like get_cpu_info or get_memory_info, and doesn't mention any prerequisites or exclusions beyond the SSH parameters.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the tool 'queries' logs and supports remote execution via SSH, but fails to disclose critical traits: whether this is a read-only operation, potential side effects (e.g., if it consumes system resources), authentication requirements beyond SSH username, rate limits, or error handling. The description adds some context (remote execution logic) but leaves significant gaps for a tool with 6 parameters and no 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 well-structured and appropriately sized. It starts with a clear purpose statement, followed by a bullet-like 'Args' section that efficiently documents each parameter. Every sentence earns its place by providing essential information, though the SSH-related details could be slightly more concise. No redundant or verbose content is 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?

Given the tool's complexity (6 parameters, no annotations, but with an output schema), the description is reasonably complete. It thoroughly documents all input parameters and their semantics. Since an output schema exists, the description doesn't need to explain return values. However, it lacks behavioral context (e.g., safety, limitations) which would be beneficial despite the output schema.

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

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

The description provides comprehensive parameter semantics beyond the input schema, which has 0% description coverage. For all 6 parameters, it explains their purpose, constraints (e.g., 'default: 100' for lines, priority enum values, SSH dependency rules), and usage examples (e.g., time formats for 'since'). This fully compensates for the lack of schema descriptions, adding significant value for agent understanding.

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

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

The description clearly states the tool's purpose: 'Query systemd journal logs with optional filters.' This specifies the verb ('query') and resource ('systemd journal logs'), making it distinct from sibling tools like 'get_service_logs' or 'read_log_file' which handle different log sources. However, it doesn't explicitly differentiate from 'get_audit_logs' which might also query logs but from a different subsystem.

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

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

The description implies usage context through parameter explanations (e.g., 'optional filters,' 'executes locally if not provided'), but lacks explicit guidance on when to use this tool versus alternatives like 'get_service_logs' or 'read_log_file.' It mentions remote execution via SSH but doesn't specify prerequisites or when remote vs local is appropriate beyond parameter requirements.

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 mentions SSH connectivity for remote execution, which adds useful context about how the tool operates. However, it lacks details on critical behavioral aspects such as permissions needed (e.g., sudo requirements), potential side effects (e.g., network timeouts), output format, or error handling, making it insufficient for a tool that interacts with system resources.

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 appropriately sized and front-loaded, with the core purpose stated first followed by parameter details. Each sentence adds value: the first defines the tool, and the subsequent ones explain parameter usage. There's no redundant or wasted text, though it could be slightly more structured (e.g., using bullet points) for optimal clarity.

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 that there's an output schema (which handles return values), the description doesn't need to explain outputs. However, for a tool with no annotations and 2 parameters, it provides basic usage but lacks completeness in areas like behavioral transparency (e.g., security implications, error cases) and differentiation from siblings. It's minimally adequate but has clear gaps 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?

The description adds significant value beyond the input schema, which has 0% description coverage. It explains the semantics of both parameters: 'host' as a remote host for SSH (optional, with local execution as default) and 'username' as required only if 'host' is provided. This clarifies usage that isn't evident from the schema alone, compensating well for the schema's lack of descriptions.

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

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

The description clearly states the tool's purpose: 'Get ports that are listening on the system.' It specifies the verb ('Get') and resource ('ports that are listening'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_network_connections' or 'get_network_interfaces', which might also involve network/port-related queries, so 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 some usage context by explaining when parameters are required (e.g., 'username' required if 'host' is provided) and the default behavior (executes locally if 'host' not provided). However, it doesn't offer explicit guidance on when to use this tool versus alternatives like 'get_network_connections' or other sibling tools, leaving the choice implied rather than clearly defined.

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

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

No annotations are provided, so the description carries the full burden. It mentions SSH connectivity and local execution, which adds some behavioral context, but fails to disclose critical traits like authentication needs (e.g., password/key requirements for SSH), error handling, rate limits, or output format details. This leaves significant gaps for a tool with remote execution capabilities.

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 appropriately sized with two sentences: one for the purpose and one for parameter guidelines. It's front-loaded with the core function and avoids redundancy. However, the parameter explanations could be slightly more integrated into the flow, but overall it's efficient with minimal waste.

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 (remote/local execution), no annotations, and an output schema (which reduces need to explain return values), the description is partially complete. It covers basic usage and parameters but lacks details on authentication, errors, and behavioral nuances, making it adequate but with clear gaps 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 0%, so the description must compensate. It explains the semantics of 'host' (remote host for SSH, optional for local execution) and 'username' (required if host is provided), adding meaning beyond the schema's basic titles. However, it doesn't cover parameter formats (e.g., host as IP/hostname) or default behaviors in detail, resulting in a baseline score.

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

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

The description clearly states the tool's purpose with 'Get memory usage including RAM and swap details,' which specifies the verb ('Get') and resource ('memory usage') with additional details ('RAM and swap'). However, it doesn't explicitly differentiate from siblings like 'get_system_info' or 'get_hardware_info' that might overlap, preventing 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 clear context for usage with the optional 'host' parameter and conditional requirement for 'username,' explaining when to use remote vs. local execution. However, it lacks explicit guidance on when to choose this tool over similar siblings (e.g., 'get_system_info' for broader data), so it doesn't fully address alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that execution can be local or remote via SSH, which is useful context, but fails to describe what 'active network connections' means (e.g., TCP/UDP connections, established/listening states), what the output format looks like, or any potential side effects, permissions needed, or rate limits. For a tool with no 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 appropriately sized and front-loaded, with the core purpose stated first ('Get active network connections.') followed by parameter details. There's no wasted text, though the structure could be slightly improved by separating usage guidance from parameter semantics more clearly.

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

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

Given the tool has an output schema (which should cover return values), no annotations, and low schema coverage, the description is moderately complete. It explains the tool's purpose and parameter interactions adequately, but lacks behavioral details like output interpretation, error conditions, or security considerations, leaving room for improvement in guiding 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?

The description adds meaningful semantics beyond the input schema, which has 0% description coverage. It explains that 'host' is optional and that execution occurs locally if not provided, and that 'username' is required if host is provided—clarifying the conditional relationship between parameters. This compensates well for the schema's lack of descriptions, though it doesn't detail parameter formats (e.g., host as IP/hostname).

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('active network connections'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'get_network_interfaces' or 'get_listening_ports', which might have overlapping network-related functionality.

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 implied usage guidance through the parameter documentation (host optional, username required if host provided), suggesting when remote vs local execution occurs. However, it doesn't explicitly state when to use this tool versus alternatives like 'get_network_interfaces' or 'get_listening_ports', nor does it mention 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description mentions SSH connectivity for remote execution, which is useful context. However, it doesn't disclose important behavioral traits like whether this requires specific permissions, what format the output takes, whether it's a read-only operation, potential rate limits, or error conditions. For a 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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by parameter documentation. There's no wasted text. However, the parameter documentation could be slightly more structured (e.g., using bullet points), and the description could benefit from a clearer separation between the purpose statement and parameter details.

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 that there's an output schema (which handles return values) and no annotations, the description provides adequate basic information about what the tool does and its parameters. However, for a tool that executes commands (potentially via SSH), it should ideally mention security implications, permission requirements, or execution context more explicitly. The description is complete enough for basic understanding but lacks depth for a tool with potential operational 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?

The schema description coverage is 0%, so the description must compensate. It provides meaningful semantics for both parameters: 'host' is described as 'Remote host to connect to via SSH (optional, executes locally if not provided)' and 'username' as 'SSH username for remote host (required if host is provided).' This adds crucial context beyond the bare schema, explaining the relationship between parameters and the local/remote execution behavior. However, it doesn't cover all potential parameter details like format requirements or examples.

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

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

The description clearly states the tool's purpose: 'Get network interface information including IP addresses.' This is a specific verb ('Get') + resource ('network interface information') combination that distinguishes it from siblings like get_network_connections (which focuses on connections rather than interfaces). However, it doesn't explicitly differentiate from all siblings, so it's not 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 implied usage guidance through the parameter documentation: it explains when 'host' is optional (executes locally if not provided) and when 'username' is required (if host is provided). However, it doesn't explicitly state when to use this tool versus alternatives like get_network_connections or get_system_info, nor does it provide any exclusions or prerequisites beyond the SSH parameters.

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 remote execution via SSH and local fallback, which is valuable context. However, it doesn't describe what 'detailed information' includes, whether this requires special permissions, potential rate limits, error conditions, or what the output looks like. For a system monitoring 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 efficiently structured with a clear purpose statement followed by parameter explanations. Every sentence adds value: the first establishes the tool's core function, and the parameter documentation provides essential usage context. It could be slightly more front-loaded with key behavioral information, but overall it's appropriately sized.

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 (process monitoring with remote capability), no annotations, and the presence of an output schema, the description does an adequate but incomplete job. It covers the basic operation and parameters well, but lacks information about permissions, error handling, output format hints, and comparison to sibling tools. The output schema existence reduces but doesn't eliminate the need for some behavioral 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 description provides clear semantic meaning for all three parameters beyond the 0% schema description coverage. It explains pid identifies the process, host enables remote SSH execution (optional with local fallback), and username is required conditionally with host. This fully compensates for the schema's lack of descriptions, though it doesn't specify format details like SSH host syntax.

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 detailed information') and resource ('about a specific process'), making the purpose immediately understandable. It distinguishes from siblings like 'list_processes' by focusing on detailed info for a specific process rather than listing all processes. However, it doesn't explicitly contrast with other process-related tools that might not exist in this set.

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

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

The description implies usage context through the parameter documentation (local vs. remote execution), but doesn't explicitly state when to use this tool versus alternatives like 'list_processes' or other system monitoring tools. It provides technical prerequisites (username required if host provided) but lacks strategic guidance on 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 full burden for behavioral disclosure. It mentions remote execution via SSH and local fallback, which is useful context, but doesn't cover critical aspects like authentication requirements beyond username, error handling, rate limits, or what the output contains. For a tool with potential remote execution and system access, 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 appropriately sized with a clear purpose statement followed by parameter explanations. Every sentence adds value, though the parameter section could be slightly more structured. It's front-loaded with the core functionality and avoids unnecessary verbiage.

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 (remote execution capability, system access) with no annotations but an output schema, the description is partially complete. It covers parameters well and states the core purpose, but lacks behavioral context about security implications, error conditions, or output format. The output schema existence reduces the need to describe return values, but other gaps remain.

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

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

Schema description coverage is 0%, so the description must compensate. It successfully adds meaning for all 4 parameters: clarifies service_name purpose, provides default value and unit for lines, explains host's optional nature and remote/local behavior, and specifies username's conditional requirement. This goes well beyond the bare schema, though some details like SSH key vs password authentication aren't covered.

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 specific action ('Get recent logs') and resource ('for a specific systemd service'), distinguishing it from siblings like get_journal_logs, get_audit_logs, or read_log_file by specifying the systemd service focus. It uses a precise verb+resource combination that leaves no ambiguity about its function.

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 through parameter explanations (e.g., 'executes locally if not provided' for host), but doesn't explicitly state when to use this tool versus alternatives like get_journal_logs or read_log_file. It provides operational context but lacks direct comparative guidance for sibling 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?

No annotations are provided, so the description carries the full burden. It mentions SSH execution for remote hosts, which adds some behavioral context (network dependency, authentication needs). However, it lacks details on rate limits, error handling, output format (though an output schema exists), or whether this is a read-only operation (implied by 'Get' but not explicit). More transparency is needed for a tool with remote execution capabilities.

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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by parameter explanations. Each sentence earns its place by clarifying usage. It could be slightly more concise by integrating parameter details more seamlessly, but overall it's efficient with minimal waste.

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 (remote execution, systemd interaction), no annotations, and an output schema (which handles return values), the description is partially complete. It covers the purpose and parameters but lacks behavioral details like error conditions or security implications. With the output schema, it doesn't need to explain return values, but more context on execution behavior would improve completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It provides meaning for all three parameters: 'service_name' as the service to check, 'host' for optional remote execution, and 'username' as required for SSH. This adds value beyond the schema's basic titles. However, it doesn't specify parameter formats (e.g., service name conventions) or examples, leaving some gaps.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('detailed status of a specific systemd service'), distinguishing it from siblings like 'list_services' (which lists services) and 'get_service_logs' (which retrieves logs). However, it doesn't explicitly differentiate from all siblings, such as 'get_system_info' which might include service status as part of broader system data.

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 through the parameter explanations: use this tool to check a specific service's status, optionally on a remote host via SSH. It doesn't provide explicit guidance on when to use this versus alternatives like 'list_services' for enumeration or 'get_service_logs' for logs, nor does it mention prerequisites or exclusions beyond SSH requirements.

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 describes the tool's function and SSH behavior for remote execution, but lacks details on permissions needed, rate limits, error handling, or output format. It doesn't contradict annotations (none exist), but could be more comprehensive.

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

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

The description is appropriately sized and front-loaded, starting with the core purpose in the first sentence, followed by a structured Args section. Every sentence adds value without redundancy, making it easy to scan and understand.

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 (2 parameters, no annotations, but with an output schema), the description is fairly complete. It covers purpose, parameters, and usage context. The existence of an output schema means return values don't need explanation, but more behavioral details (e.g., SSH requirements) could enhance completeness.

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

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

The description adds significant meaning beyond the input schema, which has 0% description coverage. The Args section explains that 'host' is optional for remote SSH connection (defaulting to local execution) and 'username' is required if host is provided, clarifying usage that isn't evident from the schema alone.

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

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

The description clearly states the tool's purpose with specific verb ('Get') and resource ('basic system information'), listing key data points like OS version, kernel, hostname, and uptime. However, it doesn't explicitly differentiate from sibling tools like get_cpu_info or get_hardware_info, which might overlap in 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 clear context for when to use the tool (to retrieve system info) and includes usage guidance in the Args section, explaining that host is optional for local execution and username is required if host is provided. It doesn't explicitly state when not to use it or name alternatives among siblings.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions SSH connectivity behavior (local vs remote execution) which is valuable, but doesn't describe what 'list' actually returns - format, structure, or content of the output. For a tool with an output schema (which exists but isn't described here), the description should at least hint at what information is returned about block devices and partitions.

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 perfectly structured and concise. The first sentence states the core purpose, followed by clear parameter documentation in a well-formatted 'Args:' section. Every sentence earns its place, with no redundant information. The information is front-loaded with the main purpose stated first.

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

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

Given the tool has an output schema (which handles return values), the description provides good contextual completeness. It covers the core purpose and fully documents both parameters. The main gap is lack of behavioral context about what 'listing' actually entails - what information is returned about devices. However, since output schema exists, this is less critical than for tools without output schemas.

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

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

The description provides excellent parameter semantics beyond the schema. With 0% schema description coverage and 2 parameters, the description fully documents both parameters: explaining that 'host' is optional for remote SSH connection (defaulting to local execution), and that 'username' is required conditionally based on whether host is provided. This completely compensates for the lack of schema descriptions.

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

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

The description clearly states the action ('List') and resource ('block devices and partitions'), making the purpose immediately understandable. It distinguishes itself from siblings like 'get_disk_usage' or 'get_hardware_info' by focusing specifically on block-level storage devices rather than usage metrics or general hardware. However, it doesn't explicitly contrast with all siblings, keeping it from 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 implied usage guidance through the parameter explanations - indicating this tool can execute locally or remotely via SSH. However, it doesn't explicitly state when to use this versus alternatives like 'get_disk_usage' for capacity information or 'get_hardware_info' for broader hardware details. No explicit 'when-not' scenarios or sibling tool comparisons are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool uses 'efficient Linux find command' and supports remote SSH execution, which adds useful context about implementation and connectivity. However, it lacks details on permissions needed, error handling, rate limits, or output format, leaving gaps for a mutation-free but system-interactive 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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by a brief implementation note, then a structured parameter list with clear explanations. Every sentence earns its place without 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 4 parameters with 0% schema coverage and an output schema present, the description does well by fully explaining parameter semantics and usage context. However, as a system tool with no annotations, it could benefit from more behavioral details like error conditions or output structure, though the output schema mitigates this gap.

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

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

Schema description coverage is 0%, so the description must compensate fully. It provides detailed semantics for all 4 parameters: 'path' as the directory to analyze, 'newest_first' as a boolean for sorting order with a default, and 'host' and 'username' for optional SSH connectivity with dependencies explained. This adds significant value beyond the bare schema.

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

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

The description clearly states the specific action ('List directories sorted by modification date') and resource ('directories'), distinguishing it from sibling tools like 'list_directories_by_name' and 'list_directories_by_size' by specifying the sorting criterion. It also mentions the implementation method ('Uses efficient Linux find command'), adding technical context.

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

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

The description provides clear context for usage by explaining when to use remote vs. local execution (if host is provided, it uses SSH; otherwise executes locally). However, it does not explicitly state when to use this tool versus alternatives like 'list_directories_by_name' or 'list_directories_by_size', missing sibling differentiation.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'Uses efficient Linux find command' which adds some implementation context, but fails to describe critical behaviors: no information on permissions required, error handling, output format, or whether it's read-only/destructive. For a tool with remote execution capability, 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 appropriately sized and front-loaded with the core purpose first. The parameter explanations are organized in a clear Args section. While efficient, the behavioral context sentence could be more integrated rather than standalone.

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

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

Given 4 parameters with 0% schema coverage and an output schema exists (which handles return values), the description adequately covers parameter semantics. However, for a tool with remote execution capability and no annotations, it lacks important behavioral context about authentication requirements, error conditions, and operational constraints that would be needed for safe use.

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

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

Schema description coverage is 0%, so the description must fully compensate. It provides clear semantic explanations for all 4 parameters: 'path: Directory path to analyze', 'reverse: Sort in reverse order (Z-A)', 'host: Remote host to connect to via SSH', and 'username: SSH username'. Each parameter's purpose and relationships (e.g., username required if host provided) are well documented beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'List directories sorted alphabetically by name' with the specific verb 'list' and resource 'directories'. It distinguishes from sibling tools like 'list_directories_by_modified_date' and 'list_directories_by_size' by specifying the sorting criterion. However, it doesn't explicitly contrast with all siblings, keeping it at 4 rather than 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 implies usage context through parameter explanations (e.g., 'executes locally if not provided' for host), but lacks explicit guidance on when to use this tool versus alternatives like other directory listing tools. No when-not-to-use or prerequisite information is provided, leaving usage decisions to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool 'Uses efficient Linux du command,' which hints at performance but doesn't detail execution behavior, error handling, or output format. It specifies remote execution via SSH with conditional parameters, adding some context, but lacks info on permissions, rate limits, or side effects. This is adequate but has gaps for a tool with no annotations.

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

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

The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by a brief implementation note and a structured parameter list. Every sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.

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 (4 parameters, no annotations, but has an output schema), the description is mostly complete. It covers the purpose, usage context, and parameter semantics adequately. Since an output schema exists, it doesn't need to explain return values, but it could benefit from more behavioral details like error conditions or execution constraints. Overall, it's sufficient but not exhaustive.

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

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

The description adds significant meaning beyond the input schema, which has 0% description coverage. It explains each parameter: 'path' as the directory to analyze, 'top_n' as the number of top largest directories with a range (1-1000), and 'host' and 'username' for optional remote SSH execution. This compensates well for the schema's lack of descriptions, though it doesn't cover all possible edge cases or defaults beyond the optional nature.

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

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

The description clearly states the tool's purpose: 'List directories sorted by size (largest first).' It specifies the verb ('list'), resource ('directories'), and sorting criteria ('by size, largest first'), which distinguishes it from sibling tools like list_directories_by_modified_date and list_directories_by_name. This makes the purpose specific and well-differentiated.

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

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

The description provides clear context for when to use the tool (to analyze directory sizes) and mentions the efficient Linux du command, which implies it's for performance-oriented tasks. However, it doesn't explicitly state when not to use it or name alternatives among siblings, such as list_directories_by_modified_date for time-based sorting. This keeps it from a perfect score.

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 describes the execution context (local vs. remote via SSH) and parameter dependencies, but doesn't mention important behavioral aspects like whether this requires elevated privileges, what format the output takes, potential performance impact, or error conditions.

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 appropriately sized and front-loaded with the core purpose first, followed by parameter explanations. Every sentence earns its place, though the formatting with 'Args:' header and bullet-like structure could be slightly more polished.

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 (process listing with remote/local options), no annotations, and the presence of an output schema, the description provides good coverage of the tool's purpose and parameter usage. However, it could benefit from mentioning typical use cases or output characteristics to be fully complete.

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

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

With 0% schema description coverage, the description fully compensates by explaining both parameters in detail: 'host' as 'Remote host to connect to via SSH (optional, executes locally if not provided)' and 'username' as 'SSH username for remote host (required if host is provided)'. This adds crucial semantic meaning beyond the bare schema.

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

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

The description clearly states the tool's purpose with specific verb ('List') and resource ('running processes'), including what information is provided ('CPU and memory usage'). It distinguishes itself from sibling tools like 'get_process_info' by focusing on listing rather than getting detailed info about a specific process.

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

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

The description provides clear context about when to use certain parameters (host and username for remote execution vs. local execution if not provided). However, it doesn't explicitly state when to use this tool versus alternatives like 'get_process_info' or other monitoring tools in the sibling list.

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

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

With no annotations provided, the description carries full burden. It mentions remote execution via SSH but doesn't disclose important behavioral traits like authentication requirements beyond username, error handling, timeout behavior, output format details, or whether this requires elevated privileges. The description provides basic context but misses critical operational details.

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

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

The description is appropriately sized with a clear purpose statement followed by parameter explanations. The Args section is well-structured. While efficient, it could be slightly more front-loaded with the most critical information about what the tool returns.

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 2 parameters with 0% schema coverage and an output schema exists, the description does reasonably well explaining parameters but lacks behavioral context for a system administration tool. The existence of an output schema means return values are documented elsewhere, but the description should still address operational considerations like permissions and error cases.

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

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

The description adds significant value beyond the schema's 0% coverage. It explains that 'host' is optional for remote SSH connection (defaulting to local execution) and that 'username' is required when host is provided. This clarifies the conditional relationship between parameters that the schema alone doesn't convey.

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 ('systemd services') with specific scope ('all' and 'with their current status'). It distinguishes from siblings like get_service_status (which likely checks a specific service) and get_service_logs (which retrieves logs rather than 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 implies usage when needing a comprehensive list of services with statuses, but doesn't explicitly state when to use this vs. alternatives like get_service_status or get_service_logs. It provides some context about remote vs. local execution but no explicit guidance on 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 full burden and does well: it discloses the whitelist constraint (critical security/access behavior), explains remote vs. local execution (SSH behavior), and specifies default values. However, it doesn't mention error handling, rate limits, or output format details, leaving some 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?

Perfectly structured: one sentence states purpose and constraint, followed by a clear Args section with bullet-like explanations. Every sentence earns its place—no fluff, front-loaded with key info. The formatting enhances readability without wasting space.

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

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

Given 4 parameters, 0% schema coverage, no annotations, but an output schema exists, the description is nearly complete. It covers purpose, constraints, and all parameters meaningfully. The output schema handles return values, so no need to explain those. Minor gaps include lack of error cases or example paths, but overall sufficient for 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 0%, so the description must compensate fully. It successfully explains all 4 parameters: 'log_path' (path to file), 'lines' (number from end with default), 'host' (remote SSH target, optional), and 'username' (required if host given). It adds crucial context like default values and conditional requirements, though it doesn't specify path format or line range limits.

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 specific action ('Read a specific log file') and resource ('log file'), distinguishing it from siblings like 'get_audit_logs' or 'get_service_logs' by specifying it reads arbitrary log files (with whitelist constraints). The verb 'Read' is precise and the scope is well-defined.

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

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

The description provides explicit guidance on when to use this tool: for reading log files (vs. other tools that fetch system info, processes, or services). It implicitly distinguishes from siblings by focusing on file-based logs rather than system logs or audit logs, though it doesn't name alternatives directly. The whitelist constraint ('whitelist-controlled via LINUX_MCP_ALLOWED_LOG_PATHS') sets clear boundaries.

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