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 for remote execution, which is valuable context, but fails to describe important behaviors like: what format the logs return in, whether this is a read-only operation, what permissions are required, potential rate limits, or error conditions. The phrase 'if available' hints at conditional access but doesn't explain the 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 efficiently structured with a clear purpose statement followed by parameter explanations in a bullet-like format. Every sentence adds value, though the opening statement could be slightly more specific about what audit logs contain. The parameter explanations are appropriately detailed without being verbose.

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

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

Given the tool has 3 parameters with 0% schema description coverage but does have an output schema, the description does a reasonable job covering parameter semantics but leaves significant behavioral gaps. For a tool that potentially involves SSH connectivity and system-level log access, more context about security requirements, error handling, and output format would be beneficial despite the output schema's existence.

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 meaningful semantic context for all three parameters that goes beyond the 0% schema description coverage. It explains that 'lines' controls the number of log lines retrieved with a default, that 'host' enables SSH connectivity to remote systems with local execution as fallback, and that 'username' is conditionally required based on host presence. This compensates 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 with a specific verb ('Get') and resource ('audit logs'), and the conditional 'if available' adds useful context. However, it doesn't explicitly differentiate from sibling tools like 'get_journal_logs' or 'get_service_logs' that also retrieve logs, leaving some ambiguity about when to choose this specific audit log tool.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_journal_logs' or 'read_log_file' from the sibling list. It mentions the conditional availability of audit logs but doesn't explain what makes audit logs distinct or when they would be preferred over other log retrieval tools.

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

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

With no annotations provided, the description carries full burden of behavioral disclosure. It mentions SSH connectivity for remote execution, which is valuable context. However, it doesn't disclose important behavioral traits like whether this requires specific permissions, what format the CPU information is returned in, whether it's a read-only operation, or any performance/rate limiting considerations. The description is minimal beyond the basic execution method.

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 - purpose statement followed by parameter documentation in a clear format. Every sentence earns its place: the first states what the tool does, and the parameter explanations are necessary for understanding the conditional logic. No wasted words or redundant information.

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

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

Given that there's an output schema (which handles return values) and only 2 parameters with good semantic coverage in the description, the description is reasonably complete for basic usage. However, for a system monitoring tool with no annotations, it should ideally mention whether this requires elevated privileges, what specific CPU metrics are returned, or any dependencies/requirements for remote SSH execution.

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 conditional relationship between host and username parameters ('required if host is provided') and clarifies that execution happens locally if host is not provided. This semantic context is crucial for proper tool invocation and isn't captured in the schema's type definitions 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 'Get CPU information and load averages', which is a specific verb+resource combination. It distinguishes itself from siblings like get_memory_info or get_system_info by focusing specifically on CPU data. However, it doesn't explicitly differentiate from get_hardware_info which might include CPU information as part of broader hardware 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 provides implied usage guidance through parameter documentation - it explains when host parameter is needed and when username is required. However, it doesn't explicitly state when to use this tool versus alternatives like get_system_info or get_hardware_info, nor does it provide context about what specific CPU information is returned versus other tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that execution can be local or remote via SSH, which adds some context, but it doesn't cover important traits like whether this is a read-only operation, potential performance impacts, error handling, or output format. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is appropriately sized and front-loaded, starting with the core purpose followed by parameter details. It uses bullet points for args, which enhances readability. There's no wasted text, and every sentence adds value, though it could be slightly more structured with explicit sections.

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 is moderately complete. It covers the purpose and parameter usage but lacks details on behavioral aspects like safety, performance, or error conditions. For a tool with 2 parameters and no annotations, it should do more to compensate, but the output schema reduces the burden slightly.

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 defaults to local execution if not provided, and that 'username' is required only if 'host' is provided. This clarifies the conditional relationship between parameters, compensating well for the lack of schema descriptions.

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

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

The description clearly states the tool's purpose: 'Get filesystem usage and mount points.' This specifies the verb ('Get') and resource ('filesystem usage and mount points'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'list_block_devices' or 'list_directories_by_size', which might also provide disk-related information, so it doesn't reach the highest score.

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

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

The description provides implied usage guidance by explaining when parameters are required ('required if host is provided'), which helps in understanding when to use remote vs. local execution. However, it doesn't explicitly state when to use this tool over alternatives like 'list_block_devices' or provide clear exclusions, 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?

No annotations are provided, so the description carries the full burden. It mentions remote execution via SSH with optional/required parameters, which is useful behavioral context. However, it lacks critical details: whether this requires specific permissions, if it's read-only or has side effects, rate limits, or what the output format looks like (though an output schema exists). For a tool that likely involves system access, this is insufficient.

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 structured Args section. Every sentence adds value—no fluff. It could be slightly more concise by integrating the Args into the main flow, but it's well-structured and 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 the tool has an output schema (so return values are documented elsewhere) and 2 parameters with 0% schema coverage, the description does a decent job. It covers parameter semantics well and states the purpose clearly. However, for a tool that likely involves system interrogation, it lacks context on permissions, safety, or how it differs from siblings, leaving gaps in 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 clear semantics for both parameters in the Args section: 'host' is for remote SSH connection (optional, defaults to local), and 'username' is required if host is provided. This adds meaningful context beyond the bare schema, explaining the relationship between parameters. With 2 parameters fully documented in description, it earns a high 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: 'Get hardware information including CPU architecture, PCI devices, USB devices, and memory hardware.' It specifies the verb ('Get') and the resource ('hardware information') with concrete examples. However, it doesn't explicitly differentiate from sibling tools like get_cpu_info or get_memory_info, which appear to be more specific subsets.

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_cpu_info or get_memory_info, nor does it explain if this is a comprehensive hardware overview versus more specific tools. The only usage context is about remote vs. local execution in the Args section, not 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 that filters are optional and describes remote execution behavior (SSH requirements), but doesn't cover important aspects like whether this is a read-only operation, potential performance impacts, error conditions, or output format. The description provides some context but leaves significant behavioral gaps unaddressed.

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

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

The description is well-structured with a clear purpose statement followed by parameter explanations. Every sentence adds value, though the parameter section could be more front-loaded with critical information. The formatting with 'Args:' heading helps organization, making it efficient despite covering 6 parameters.

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

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

Given the tool's moderate complexity (6 parameters, no annotations, but has output schema), the description provides good coverage. The parameter explanations are thorough, and the presence of an output schema means return values don't need description. However, some behavioral context (like read-only nature, error handling) is missing, preventing a perfect score.

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 compensates fully by providing clear semantic explanations for all 6 parameters. Each parameter gets specific context: 'unit' filters by systemd unit, 'priority' lists valid values, 'since' provides format examples, 'lines' specifies default, and 'host'/'username' explain SSH dependency. This adds substantial 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 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'. However, it doesn't explicitly differentiate from 'get_audit_logs' or explain how journal logs differ from other log 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 implies usage through the parameter explanations (e.g., 'optional filters', 'required if host is 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 as an option, which provides some context, but doesn't specify scenarios where journal logs are preferred over other log sources.

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. While it mentions the SSH execution context, it doesn't describe what the tool actually returns (listening ports format), whether it requires special permissions, potential side effects, or error conditions. For a system diagnostic 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 appropriately sized with three sentences: a clear purpose statement followed by parameter explanations. The structure is front-loaded with the core functionality. While efficient, the parameter section could be slightly more structured, but overall it avoids unnecessary verbosity.

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 presumably describes the return format), the description doesn't need to explain return values. However, for a system diagnostic tool with no annotations and 2 parameters, the description should provide more behavioral context about execution constraints, permissions needed, or typical use cases. The parameter explanations help, but overall completeness is adequate but not comprehensive.

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 parameter context beyond the schema. The schema has 0% description coverage and only shows titles, while the description explains that 'host' is optional for remote SSH execution (defaulting to local), and 'username' is required only if host is provided. This compensates well for the schema's lack of documentation, though it doesn't cover all possible parameter nuances.

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.' This is a specific verb+resource combination that distinguishes it from sibling tools like get_network_connections or get_network_interfaces, which focus on different network aspects. However, it doesn't explicitly differentiate from all siblings, just implies a different focus.

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: it can execute locally or remotely via SSH. However, it doesn't explicitly state when to use this tool versus alternatives like get_network_connections or get_network_interfaces, nor does it provide any exclusion criteria or prerequisites beyond the 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?

No annotations are provided, so the description carries the full burden. It mentions remote execution via SSH and local fallback, which adds some behavioral context, but fails to disclose critical traits like whether this is a read-only operation, potential performance impacts, error handling, or output format. For a tool with system-level access, 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 appropriately sized with two sentences: one for the core purpose and one for parameter details. It's front-loaded with the main function, and the parameter explanations are necessary given the low schema coverage. There's minimal waste, though it could be slightly more structured.

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

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

Given the tool's moderate complexity (2 parameters, system-level operation) and the presence of an output schema (which handles return values), the description is partially complete. It covers the purpose and parameters well but lacks behavioral context like safety or performance, leaving gaps that annotations or more detail could fill.

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 effectively explains both parameters: 'host' as an optional remote SSH target and 'username' as required for remote connections. This adds meaningful semantics beyond the schema's basic titles, clarifying usage conditions and dependencies between parameters.

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

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

The description clearly states the tool's purpose with 'Get memory usage including RAM and swap details,' which is a specific verb+resource combination. It distinguishes itself from siblings like get_cpu_info or get_disk_usage by focusing on memory metrics. However, it doesn't explicitly differentiate from get_system_info, which might also include memory data, making it slightly less precise.

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

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

The description implies usage by detailing parameters for remote vs. local execution, suggesting it's for retrieving memory info from a system. However, it lacks explicit guidance on when to use this tool versus alternatives like get_system_info or get_hardware_info, and doesn't 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?

No annotations are provided, so the description carries the full burden. It mentions that the tool can execute locally or remotely via SSH, which adds some behavioral context. However, it fails to disclose critical traits: whether this is a read-only operation, what format the output takes, potential security implications of SSH usage, or any rate limits. For a tool with network/SSH capabilities and no annotations, 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 purpose clearly, followed by parameter details. Every sentence earns its place by explaining key usage aspects. It could be slightly more structured (e.g., bullet points), but it's efficient without 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 (network/SSH operations), no annotations, and an output schema (which handles return values), the description is partially complete. It covers parameters well but lacks behavioral transparency (e.g., safety, output format hints). For a tool with potential security implications, it should do more to guide safe usage.

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 does so by explaining both parameters: 'host' (remote host for SSH, optional with local execution fallback) and 'username' (required if host is provided). This adds essential meaning beyond the bare schema, clarifying the conditional relationship between parameters and the tool's dual execution modes.

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 active network connections.' It specifies the verb ('Get') and resource ('active network connections'), which distinguishes it from sibling tools like get_network_interfaces or get_listening_ports. However, it doesn't explicitly differentiate from all siblings (e.g., get_process_info might also involve network connections), 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 parameter documentation: it explains when 'host' and 'username' are required/optional (e.g., 'host' is optional, 'username' required if host is provided). However, it lacks explicit guidance on when to use this tool versus alternatives like get_listening_ports or get_network_interfaces, and doesn't 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions SSH connectivity for remote execution but doesn't describe what happens on failure, whether it requires sudo/root privileges, what format the output takes, or any rate limits. The description provides basic execution context but lacks important behavioral details for a tool that interacts with system networking.

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 documentation. Both sentences earn their place - the first establishes what the tool does, the second explains parameter dependencies. It's appropriately sized for a 2-parameter tool, though it could be slightly more front-loaded with the most critical information.

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

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

Given that there's an output schema (which handles return values), no annotations, and only 2 parameters with good description coverage, the description is moderately complete. However, for a tool that executes commands (potentially via SSH) and returns system information, it should mention authentication requirements, error conditions, or execution context more explicitly 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?

The description adds significant semantic value beyond the input schema, which has 0% description coverage. It explains that 'host' is optional and defaults to local execution when not provided, and clarifies that 'username' is required only when host is specified. This compensates fully for the schema's lack of parameter descriptions, providing essential context for proper tool invocation.

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 network interface information including IP addresses' - a specific verb ('Get') and resource ('network interface information') with additional detail ('IP addresses'). It distinguishes itself from siblings like get_network_connections by focusing on interfaces rather than connections, though the distinction could be more explicit.

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

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

The description provides implied usage guidance through parameter documentation - it explains when host is optional (executes locally) 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 mention prerequisites like SSH configuration or authentication methods.

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 when host is provided, which adds some behavioral context. However, it doesn't disclose critical traits like whether this is a read-only operation, potential performance impacts, error conditions, authentication requirements beyond SSH username, or what 'detailed information' includes. The description is insufficient for a mutation-sensitive agent.

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 in a structured 'Args:' section. Each sentence earns its place by adding value. However, the formatting with quotes and line breaks could be slightly cleaner, and the purpose statement is somewhat generic.

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 3 parameters with 0% schema coverage and no annotations, the description does well on parameters but lacks behavioral transparency. The existence of an output schema means return values don't need explanation, but the description should still cover operational aspects like safety, errors, or dependencies. It's minimally adequate but has clear gaps for a tool that might involve remote execution.

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 clear semantic explanations for all three parameters: pid as 'Process ID', 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 meaningful context beyond the bare schema types, though it could elaborate on pid format or 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 unambiguous. It distinguishes from siblings like 'list_processes' by focusing on a single 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 parameter explanations (e.g., host optional for local execution, username required if host provided), which helps understand when to provide certain inputs. However, it lacks explicit guidance on when to choose this tool over alternatives like 'list_processes' or other monitoring tools, and doesn't 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It describes the remote/local execution behavior and parameter dependencies, but doesn't mention important aspects like authentication requirements beyond SSH username, error conditions, rate limits, or what the output contains. For a tool with 4 parameters and 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?

Perfectly structured with a clear purpose statement followed by parameter explanations in a bullet-like format. Every sentence earns its place, providing essential information without redundancy. The description is appropriately sized for a 4-parameter 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 has an output schema (which handles return values), 4 parameters with 0% schema coverage, and no annotations, the description does well on parameters but lacks behavioral context. It's adequate for basic usage but incomplete for understanding error handling, authentication details, or operational constraints.

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 all 4 parameters in detail: service_name purpose, lines default value and meaning, host's optional/local behavior, and username's conditional requirement. Each parameter gets clear semantic context beyond just naming them.

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

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

The description clearly states the specific action ('Get recent logs') and resource ('for a specific systemd service'), distinguishing it from sibling tools like get_journal_logs (general logs) or get_service_status (status rather than logs). The verb+resource combination is precise and unambiguous.

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

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

The description implies usage context 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 clear operational guidance but lacks 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?

No annotations are provided, so the description carries the full burden. It mentions remote execution via SSH and local fallback, but does not disclose critical behavioral traits such as required permissions (e.g., sudo access), error handling (e.g., if service doesn't exist), output format details, or rate limits. This leaves significant gaps for an agent.

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 structured 'Args:' section that efficiently documents parameters. Every sentence earns its place with no wasted words.

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

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

Given the tool's moderate complexity (3 parameters, no annotations, but with an output schema), the description is partially complete. It covers parameters well but lacks behavioral context (e.g., permissions, errors). The output schema existence means return values need not be explained, but other operational details are missing.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for all three parameters: 'service_name' is explained as the service name, 'host' for remote SSH connection with local fallback, and 'username' as required if host is provided. This goes beyond the schema's basic titles.

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 resource 'detailed status of a specific systemd service', making the purpose explicit. It distinguishes from siblings like 'list_services' (which lists services) and 'get_service_logs' (which retrieves logs rather than status).

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

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

The description provides clear context for when to use optional parameters (host and username for remote execution), but does not explicitly mention when not to use this tool versus alternatives like 'get_system_info' or 'list_services'. It implies usage for checking service status locally or remotely.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool can execute locally or remotely via SSH, which is useful behavioral context. However, it lacks details on permissions needed, rate limits, error handling, or what the output contains beyond the listed fields, leaving gaps in behavioral understanding.

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 in the first sentence. The Args section is necessary due to low schema coverage, but the structure is clear and efficient, with no redundant or wasted sentences.

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 reasonably complete. It covers the purpose, parameters, and usage context. Since an output schema exists, it need not explain return values, but it could benefit from more behavioral details like error cases or output format hints.

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: 'host' is explained as optional for remote SSH connection (defaults to local), and 'username' is required if host is provided. This clarifies usage beyond the schema's basic types and defaults, though it could specify format details like SSH host strings.

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') and resource ('basic system information'), listing concrete examples of what information is retrieved (OS version, kernel, hostname, uptime). It distinguishes itself from siblings like get_cpu_info or get_memory_info by covering a broader set of system-level details rather than specific components.

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 on when to use the tool (for basic system info) and includes usage guidance in the Args section about remote vs. local execution. However, it does not explicitly state when NOT to use it or name specific alternatives among siblings for more detailed or component-specific information.

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 explains the SSH/local execution behavior, it doesn't mention important aspects like: what format the output takes, whether this requires elevated privileges, potential performance impact on the target system, or error conditions. For a system-level 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 well-structured with a clear purpose statement followed by parameter explanations. Both sentences earn their place by providing essential information. It could potentially be slightly more concise by combining the parameter explanations, but overall it's efficient and front-loaded with the core functionality.

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

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

Given that an output schema exists (which will handle return values), the description focuses appropriately on what the tool does and how to use it. The parameter explanations are thorough, and the purpose is clear. The main gap is the lack of behavioral context about permissions, output format details, or system impact, but with an output schema covering returns, this is less critical.

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 0% schema coverage. It explains that 'host' is optional and that omitting it causes local execution, clarifies that 'username' is required only when host is provided, and gives the conditional logic between parameters. This fully compensates for the complete lack of schema descriptions and adds meaningful context about parameter interactions.

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 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, 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 context through the parameter explanations - it suggests using this tool for local execution when no host is provided, or for remote SSH execution when host/username are provided. However, it doesn't explicitly state when to choose this tool versus alternatives like get_disk_usage (which might show usage statistics rather than device listings) or provide clear exclusion criteria. The guidance is functional but not comprehensive.

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

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

No annotations are provided, so the description carries the full burden. It discloses behavioral traits such as using 'efficient Linux find command' and execution context (local vs. remote via SSH). However, it lacks details on permissions needed, error handling, or output format, which are important for a tool with remote execution capabilities. The description does not contradict any 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 implementation details and parameter explanations. Every sentence adds value without redundancy, making it efficient and well-structured for quick understanding.

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 (remote execution, sorting) and the presence of an output schema, the description is mostly complete. It covers purpose, usage context, and parameter semantics. However, it lacks details on behavioral aspects like error handling or authentication requirements for SSH, which are important given the remote execution feature. The output schema likely handles return values, so that gap is mitigated.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning beyond the schema by explaining parameter semantics: 'path' is for 'Directory path to analyze', 'newest_first' controls sorting order, 'host' enables remote SSH execution, and 'username' is required for remote use. This covers all parameters, but lacks details like format constraints or examples, preventing a score of 5.

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 modification date.' It specifies the verb ('list'), resource ('directories'), and sorting criterion ('by modification date'), and distinguishes it from sibling tools like 'list_directories_by_name' and 'list_directories_by_size' by explicitly mentioning the sorting method.

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: 'Uses efficient Linux find command' and explains when to use optional parameters (e.g., 'host' for remote execution, 'username' if host is provided). However, it does not explicitly state when to use this tool versus alternatives like 'list_directories_by_name' or 'list_directories_by_size', which would be needed for a score of 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool uses 'efficient Linux find command' which hints at performance characteristics, and describes remote execution via SSH when host is provided. However, it doesn't cover important aspects like error handling, permission requirements, output format, or whether it's read-only/destructive.

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. A clear purpose statement is followed by a well-organized parameter section where every sentence earns its place. No redundant information, and the formatting with 'Args:' header makes it easy to parse.

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

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

Given the tool has 4 parameters with 0% schema coverage and no annotations, the description does an excellent job explaining parameter semantics. However, since there's an output schema (per context signals), the description doesn't need to explain return values. The main gap is lack of behavioral context about permissions, errors, or safety, which would be helpful 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?

With 0% schema description coverage, the description fully compensates by providing clear semantic explanations for all 4 parameters. It explains what 'path' represents, clarifies 'reverse' controls sort direction with default, and describes the conditional relationship between 'host' and 'username' for remote execution. 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 tool's purpose with a specific verb ('List') and resource ('directories'), and distinguishes it from siblings by specifying alphabetical sorting by name (vs. by modified date or size in list_directories_by_modified_date and list_directories_by_size). The mention of 'efficient Linux find command' adds implementation context that further clarifies 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 about when to use this tool (for listing directories sorted alphabetically) and implicitly distinguishes it from sibling tools that sort by other criteria. However, it doesn't explicitly state when NOT to use it or name specific alternatives, which prevents 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 mentions the implementation method ('Linux du command') and remote execution capability via SSH, which adds useful context. However, it doesn't disclose important behavioral traits like whether this is a read-only operation, potential performance impact on large directories, error conditions, or output format 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 perfectly structured and concise. It begins with a clear purpose statement, then provides a well-organized parameter section with bullet-like formatting. Every sentence earns its place, with no wasted words or redundant information.

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

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

Given the tool's moderate complexity (4 parameters, remote execution capability) and the presence of an output schema, the description is mostly complete. It covers all parameters thoroughly and provides implementation context. The main gap is lack of behavioral details about the operation's safety and performance characteristics, which would be more important if no output schema existed.

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 providing detailed parameter explanations. Each of the 4 parameters is clearly documented with purpose, constraints (e.g., '1-1000' for top_n), and dependencies ('required if host is provided'). 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 tool's purpose with specific verb ('list directories sorted by size') and resource ('directories'), distinguishing it from sibling tools like list_directories_by_modified_date and list_directories_by_name. It specifies the sorting order ('largest first') and mentions the underlying implementation ('efficient Linux du command'), providing clear differentiation.

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

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

The description provides clear context about when to use this tool (for analyzing directory sizes with sorting) and implicitly distinguishes it from siblings that list by other criteria. However, it doesn't explicitly state when NOT to use it or name specific alternatives, which prevents 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 mentions SSH connectivity for remote execution, which adds context, but fails to disclose critical traits like whether this is a read-only operation, potential performance impact, output format details (though output schema exists), or error handling. For a tool that interacts with system processes, 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 appropriately sized with two sentences: one for the core purpose and one for parameter semantics. It's front-loaded with the main functionality, and the parameter explanations are necessary given the low schema coverage. There's minimal waste, though the structure could be slightly improved by separating usage notes 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's moderate complexity (2 parameters, system interaction), no annotations, and an output schema present, the description is partially complete. It covers the purpose and parameter semantics adequately but lacks behavioral context like safety, permissions, or execution details. The output schema mitigates the need to describe return values, but overall completeness is just adequate with clear 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 0%, so the description must compensate. It adds meaningful semantics by explaining that 'host' is optional for remote SSH connection (defaulting to local execution) and 'username' is required if host is provided. This clarifies the conditional relationship between parameters beyond what the schema's types and defaults indicate, though it doesn't cover all possible edge cases.

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 'running processes' with specific attributes 'CPU and memory usage', making the purpose explicit. It distinguishes from siblings like 'get_process_info' by focusing on listing with metrics rather than detailed information about a specific process. However, it doesn't explicitly mention how it differs from 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 implies usage through parameter explanations (e.g., host optional for local execution, username required if host provided), suggesting when to use remote vs. local. However, it lacks explicit guidance on when to choose this tool over alternatives like 'get_process_info' or other monitoring tools, leaving some ambiguity for the agent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions SSH connectivity and local execution, but doesn't describe what the tool returns (though an output schema exists), potential errors, rate limits, or authentication requirements beyond username. 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 efficiently structured with a clear purpose statement followed by parameter explanations. Every sentence adds value: the first states what the tool does, and the next two clarify parameter usage. No wasted words or redundancy.

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

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

Given the tool's moderate complexity (2 parameters, no annotations, but with an output schema), the description is reasonably complete. It covers the core purpose and parameter semantics adequately. The existence of an output schema means return values don't need explanation, but more behavioral context would 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 meaningful context beyond the input schema, which has 0% description coverage. It explains that 'host' is optional and triggers local execution if not provided, and that 'username' is required conditionally. This compensates well for the schema's lack of descriptions, though it doesn't cover all possible parameter nuances.

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 all systemd services with their current status.' It specifies the verb ('List') and resource ('systemd services') with scope ('all'). However, it doesn't explicitly differentiate from sibling tools like 'get_service_status' or 'get_service_logs', 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 implied usage guidance by explaining when parameters are required ('required if host is provided'), but it doesn't explicitly state when to use this tool versus alternatives like 'get_service_status' or 'get_service_logs'. No exclusions or clear context for tool selection 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. It discloses key behavioral traits: the tool reads log files (implying read-only), mentions whitelist control via LINUX_MCP_ALLOWED_LOG_PATHS (important access restriction), and explains SSH behavior for remote execution. However, it doesn't cover rate limits, error handling, or output format 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 and front-loaded: the first sentence states the core purpose and key constraint (whitelist), followed by a clear Args section with concise explanations for each parameter. Every sentence adds value with no wasted words.

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

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

Given the tool's moderate complexity (4 parameters, no annotations, but with output schema), the description is mostly complete. It covers purpose, usage context, parameters, and key behavioral constraints. However, it doesn't mention the output schema's existence or what the tool returns (though the output schema handles that), and lacks details on error cases or the whitelist mechanism.

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 adds significant meaning beyond the schema: explains that log_path is for log files with whitelist control, lines retrieves from the end with a default, host is for remote SSH (optional), and username is required if host is provided. This covers all 4 parameters thoroughly.

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

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

The description clearly states the verb ('Read') and resource ('a specific log file'), and distinguishes it from siblings by specifying it's for log files (not system info, processes, etc.) and mentioning whitelist control via LINUX_MCP_ALLOWED_LOG_PATHS, which is unique among the sibling tools.

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

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

The description provides clear context for usage: it's for reading log files with path-based access control. It implies when to use (for log files) vs. alternatives like get_journal_logs or get_service_logs, but doesn't explicitly name them or state exclusions. The optional SSH parameters give guidance on remote vs. local execution.

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