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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It does disclose meaningful behavior: it safely walks the filesystem, does not follow symlinks, and skips virtual pseudo-filesystems like /proc, /sys, /dev, and /run. It also states the return format as a JSON string. It does not mention permission requirements or exact error conditions, but the core behavioral traits are covered.

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 efficient. It front-loads the purpose, then provides a concise safety note, clearly labeled Args, and a clearly labeled Returns section. Every sentence provides necessary information and no filler 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?

For a read-only analysis tool with four optional parameters, the description covers all parameters, explains traversal behavior, notes exclusions, and specifies the return format. Even though an output schema exists, the description still appropriately summarizes what the returned JSON contains. Nothing critical is missing for correct tool invocation.

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

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

The input schema has 0% description coverage, so the description must compensate, and it does. Every parameter is explicitly explained with its meaning, default, and applicable constraints: target_path with default '/var', max_depth with range 1-5, min_size_mb with threshold meaning, and top_n with range 1-50. This fully clarifies 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 uses a specific verb and resource: 'Analyze disk usage for a directory to discover space bottlenecks and large files.' It clearly distinguishes itself from sibling tools focused on logs, processes, security, or services, and immediately conveys what this tool does and why it exists.

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 gives clear context for when to use the tool: when disk-usage analysis or space-bottleneck discovery is needed. It does not explicitly name alternatives or exclusions, but none of the sibling tools clearly overlap with this disk-analysis function, so the lack of explicit when-not-to-use guidance is acceptable.

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 must convey behavior. It states it 'audits' and returns results, implying a read-only operation, but it does not explicitly guarantee no modifications are made.

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

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

The description is extremely concise, containing only two sentences. It quickly communicates the purpose and return value without any filler 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 simplicity and lack of parameters, the description is largely complete: it explains the action, the target (SSH daemon configuration), and the output format. It lacks explicit mention of scope (local system), but this is reasonably implied.

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?

There are no parameters, so the empty input schema leaves no room for missing documentation. The description accurately reflects that the tool operates without arguments, achieving the baseline for zero-parameter tools.

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 audits the SSH daemon configuration against security best practices, specifying the action and resource. It is distinct from all sibling tools, which focus on other system aspects.

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

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

The description implies usage for security auditing but does not explicitly state when to prefer this tool over alternatives. However, since no sibling tool covers SSH config audits, the context is somewhat clear.

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

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

With no annotations, the description carries the behavioral burden. It communicates that the tool performs DNS probes, can accept custom domains, defaults to public services, and returns a JSON verdict. 'Audit' implies a non-mutating diagnostic operation, which is useful transparency even though explicit safety or permission details are not stated.

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

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

The description is compact and well-structured with Args and Returns sections. The main purpose is front-loaded, every sentence adds useful information, and there is no repetition of schema fields.

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

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

For a one-optional-parameter diagnostic tool, the description covers purpose, input behavior, default behavior, and return content. It is complete enough for an agent to invoke it confidently. Minor gaps such as timeout behavior or possible failure modes are not described, but the output schema may cover return details.

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

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

The schema only defines 'domains' as an optional array/null with no description. The tool description compensates by explaining that domains is a custom probe list and defaults to essential public services. This adds real meaning beyond the schema, though it does not specify domain formatting constraints or example values.

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 uses a specific verb ('Audit') and clearly identifies the resource: system DNS resolution health, configured nameservers, and query responsiveness. This distinguishes it from the sibling health/network tools, which target different subsystems.

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 gives clear context for when to use the tool: when DNS resolution health, nameserver configuration, or query latency needs to be assessed. It does not explicitly name alternatives or provide when-not-to-use guidance, but the purpose is specific enough for an agent to route correctly.

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

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

With no annotations, the description carries the burden of explaining behavior. The verb 'Inspect' conveys a non-destructive read operation, and the description states what will be returned: a JSON string with failed logins and top offending IPs. It does not discuss authentication or data source, but nothing suggests hidden side effects or destructive 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 compact and well-structured with clear Args and Returns sections. Every sentence adds useful information, and the main purpose is front-loaded.

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

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

For a single-parameter read-only tool with an output schema present, the description is sufficiently complete. It covers what the tool does, what the parameter means, and what kind of result to expect.

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 only parameter, limit, is fully explained in the description: it is the number of recent failed attempts to inspect, with a default of 20 and a max of 100. This adds essential information not present in the schema, especially since schema description coverage is 0%.

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

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

The description uses a specific verb ('Inspect'), a clear resource ('recent failed SSH login attempts'), and a goal ('detect brute-force attackers'). This separates it from sibling tools like get_fail2ban_status and audit_ssh_config.

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 when to use the tool: when checking recent failed SSH login attempts to detect brute-force activity. It gives clear context but does not explicitly mention alternatives or when-not-to-use conditions.

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

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

With no annotations, the description carries the full behavioral burden. It discloses caching behavior, network/CPU overhead, direct GitHub API usage, and the JSON return contents. It does not explicitly state that the operation is read-only or describe failure behavior, but the disclosed traits go well beyond the schema.

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 front-loaded with the core purpose, followed by caching behavior, parameter details, and return format. Every sentence adds information and the structure is easy to scan.

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

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

For a single-parameter optional tool with no output schema, the description covers purpose, caching, the parameter, and the return fields. It is slightly less explicit about exact JSON key names or error handling, but it provides enough for an agent to invoke the tool and interpret the result.

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

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

The input schema only provides a title and default for force_refresh, but the description adds meaningful semantics: 'Set to True to bypass cache and query GitHub API directly.' This explains the behavioral consequence of the parameter, which the schema alone does not 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 opens with a specific verb and resource: 'Check if a newer version or commit of VPS-Guardian-MCP is available on GitHub.' This clearly distinguishes the tool from the unrelated server-operation siblings and states exactly what the tool does.

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 gives clear usage context by explaining the 5-minute cache and explicitly telling the agent to set force_refresh to True to bypass cache and query GitHub API directly. It does not explicitly compare with alternatives, but no sibling tool offers this functionality, so the guidance is sufficient.

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

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

No annotations are present, so the description must carry behavioral context. It states the operation audits logs and describes the return as a JSON string with categorized errors, root causes, and critical counters. It does not explicitly mention side effects, permissions, or rate limits, though the read-only nature is reasonably inferred from 'audit'.

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 compact: one purpose sentence, one parameter line, and one return line. Every sentence adds information, and the key action and resource are front-loaded with no filler.

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

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

For a single-parameter read-only diagnostic tool with an output schema, the description covers purpose, parameter semantics, and return shape. It lacks explicit alternative guidance and behavioral caveats, but nothing essential is missing for correct invocation.

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

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

The schema has no property descriptions (0% coverage), so the description's Args section is the only source of parameter meaning. It defines limit as the maximum number of error entries and gives the range 1–50 and default 20, fully compensating for the schema gap.

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

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

The description clearly states a specific action and resource: 'Audit kernel logs for hardware failures, storage I/O errors, or application segfaults'. The error categories give concrete purpose, but it does not explicitly distinguish itself from overlapping siblings such as check_oom_events or read_service_logs.

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?

There is no guidance on when to use this tool versus alternatives such as check_oom_events or get_system_health. The purpose sentence implies kernel-log triage, but no exclusions, contexts, or alternative routing 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 uses the word 'Inspect' suggesting a read-only operation and describes the output, but it does not explicitly confirm no side effects, does not mention permissions required, and does not describe failure modes (e.g., missing logs, insufficient permissions). This is adequate but not thorough.

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

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

The description is compact and well-structured, with a clear purpose statement, a one-line parameter explanation, and a return-value note. No redundant or extraneous text 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 simple nature of the tool (one optional parameter, read-only intent), the description is nearly complete. It explains what the tool does and what it returns, but it omits details about behavior when no OOM events exist or how the JSON output is structured. These gaps are minor for this diagnostic tool.

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

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

The single parameter 'limit' has no schema description (0% coverage), but the description fully compensates by explaining its meaning, range (1 to 50), and default value (10). The parameter is effectively documented.

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 ('Inspect kernel logs') and the specific subject ('Linux Out-Of-Memory (OOM) Killer invocations'). It also explains what is surfaced (terminated processes, PIDs, and RSS memory), leaving no ambiguity about the tool's purpose.

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

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

The description does not explicitly state when to use this tool versus alternatives. While the focus on OOM events implies a diagnostic use case, it lacks direct guidance such as 'use this when checking for memory pressure' or 'use check_kernel_errors for general kernel issues'. No when-not-to-use conditions are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It helps by stating the return payload: JSON with active state, enabled state, and recent status logs. Yet it does not explicitly disclose that the operation is read-only, what happens when the service does not exist, or whether elevated permissions are required to query status. This leaves some behavioral ambiguity.

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 compact and efficiently structured with Args and Returns sections. The first sentence immediately states the tool's purpose, and every subsequent sentence adds necessary details about the parameter and output. There is no inflated or redundant wording.

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

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

For a simple tool with one required string parameter, the description is largely complete: it names the service, gives examples, and describes the expected return content. It does not explain error cases or permission requirements, but the output schema already covers the return shape, and the tool's scope is narrow. A small gap remains in not explicitly distinguishing from failed-unit or service-log 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?

Schema description coverage is 0%, so the description must compensate, and it does. The Args section defines service_name as 'Name of the system service' and gives concrete examples ('nginx', 'mysql', 'postgresql', 'ufw', 'docker'). This adds real meaning beyond the schema's bare 'Service Name' title, though it could have specified whether the '.service' suffix is accepted.

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 opens with a specific verb and resource: 'Check the operational status of a systemd service unit.' It clearly distinguishes this from sibling tools like list_systemd_timers, get_failed_systemd_units, and read_service_logs by focusing on the status of a single named service unit. The Returns section further clarifies what is inspected: active state, enabled state, and recent status logs.

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 clearly implies the use case: you need the operational status of a specific systemd service. It provides a named service parameter with examples, which is enough context to select it over broader tools like get_system_health or get_failed_systemd_units. However, it does not explicitly name alternatives or provide when-not-to-use guidance, so it misses full 5-level routing clarity.

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 the audit scope (host certificates, specifically Let's Encrypt / Certbot) and the exact return shape (JSON string with domains, expiration dates, days remaining, and warning flags). The verb 'Audit' implies a read-only operation, but it does not explicitly state that there are no side effects or mention any permission requirements.

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 two concise sentences: a clear purpose statement followed by a return-value summary. It is front-loaded and every sentence adds necessary information with no redundant text or filler.

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

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

For a zero-parameter tool, the description is complete: it states the exact subject (host SSL/TLS certificates, Let's Encrypt / Certbot) and enumerates the return fields. An output schema reportedly exists, so return format does not need explanation. There are no missing invocation details.

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

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

The input schema has zero parameters, so the baseline is 4. There is no parameter meaning to add, and the description correctly avoids inventing parameters. Nothing is lacking on this dimension.

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 uses a specific verb ('Audit') with a clear resource ('SSL/TLS certificates configured on the host') and adds scope as Let's Encrypt / Certbot. It stands apart from all sibling tools, none of which target SSL/TLS certificate state, so an agent can confidently identify what this tool does.

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?

Usage context is implied by the tool's name and description: it is for auditing SSL/TLS certificates. However, there is no explicit statement of when to use this tool versus alternatives, nor any exclusion or comparison to sibling audit/health tools. That is implied usage, not explicit guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses read-only audit behavior, checks the reboot-required file, queries package managers/CVE information, caches results for 5 minutes, and explains that force_refresh bypasses the cache. It does not explicitly state permission requirements or that it makes no system changes, but 'audit/checks/returns' strongly implies a non-mutating operation.

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

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

The description is compact and well-structured. It front-loads the purpose, then adds concrete details about what is checked, caching, parameters, and return value. Every sentence earns its place with no filler 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?

For a simple one-parameter audit tool with an output schema, the description is largely complete: purpose, checked sources, caching behavior, parameter semantics, and return content are all covered. Minor gaps include platform or root-permission requirements and potential failure modes, but these are not critical given the tool's low 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 provides 0% description coverage, and the description fully compensates for the only parameter. It explains that force_refresh=True bypasses the 5-minute cache and queries package managers directly, which gives the agent meaningful behavioral knowledge beyond the schema's default 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 uses a specific verb and resource: 'Audit available operating system package updates and pending security patches.' It is clear and distinct from most siblings, and enumerates concrete checks (reboot, upgradable packages, CVE patches). It does not explicitly contrast with the close sibling check_guardian_updates, so it stops short of full sibling differentiation.

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

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

The description implies when to use the tool: whenever OS package update or security patch status is needed. It provides useful operational context like the 5-minute cache and force_refresh behavior, but it never explicitly states when not to use it or names alternatives like check_guardian_updates. Usage guidance is implied rather than 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 the full behavioral disclosure burden. It explains that a tar.gz archive is created, where it is stored, and what the return JSON contains. It does not mention overwrite behavior or permission prerequisites, but it is reasonably transparent for a non-destructive operation.

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

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

The description is concise, front-loaded with the primary action, and uses a clear structure: action, destination, allowed source locations, Args, Returns. Every sentence contributes useful information without redundancy.

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

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

The description covers the essential aspects needed to call the tool: purpose, source restrictions, destination, parameters, and return format. Since an output schema exists, the return description is a helpful addition rather than a necessity. Minor gaps such as failure conditions and naming conventions prevent 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?

The schema provides zero description coverage, so the description must fully explain both parameters. It does: backup_type is defined as an identifier label with examples, and source_path is defined as the target directory. This is sufficient for an agent to populate both required arguments correctly.

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 opens with a specific verb and resource: 'Create a compressed tar.gz archive of an authorized website or configuration directory.' It clearly distinguishes this from all sibling tools, which are mostly read-only audit and monitoring tools. The scope is 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 provides concrete usage constraints by listing permitted source locations and stating that archives are saved to an isolated backup repository. It does not explicitly name alternative tools or state when not to use it, but the allowed paths and purpose provide clear contextual guidance.

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

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

With no annotations provided, the description carries the full transparency burden and does it well: it lists exact side effects such as 'Deep prune of unused containers, networks, images, and volumes', 'Terminates a runaway process by PID', and 'Truncates journal logs to limit'. It also discloses the return format including 'security error'. It stops short of stating irreversibility or potential service-impact severity, which keeps it from a 5.

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 front-loaded with the primary purpose and then organized into a compact bullet list, an Args section, and a Returns section. Every sentence carries meaningful information; the length is justified by the number of actions described. No filler or repetition.

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

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

Given the tool's complexity, the output schema presence, and the absence of annotations, the description covers all actions, their target semantics, and the return shape. It could additionally note prerequisites like root permissions or the fact that several actions are irreversible, but the current text is sufficiently complete for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must fully compensate. It does so by enumerating every allowed action_name value with concrete target requirements and examples such as target='nginx' and target='12345'. This is far more informative than the schema's bare strings and gives an agent everything needed to construct valid calls.

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 opens with a specific verb and resource: 'Execute an emergency recovery operation from a strictly whitelisted list.' It clearly differentiates itself from the read-only diagnostic sibling tools such as check_service_status and analyze_disk_usage by framing this as a recovery/action tool. The bullet-list of allowed actions makes the tool's purpose unmistakable.

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 phrase 'emergency recovery operation' establishes clear context for when this tool is appropriate, and the 'strictly whitelisted' phrasing imposes a strong constraint against arbitrary actions. It does not name sibling alternatives or explicitly say when not to use them, but the contrast with the read-only sibling names is evident. The per-action target requirements also give concrete operational guidance.

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

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

With no annotations, the description carries the full burden and does a solid job: it reveals the discovery behavior, supported database types, scope ('in application directories'), and the exact JSON return content including operational state, socket accessibility, and ping latency. It does not explicitly state that it is read-only, but 'discover and verify' strongly implies non-destructive 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 compact and front-loaded: first the core purpose, then the detection scope, then the return format. Every sentence adds useful information and there is no filler or redundancy that weakens the definition.

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

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

For a zero-parameter health-check tool with an output schema, the description is largely complete: it defines scope, supported engines, and return contents. It leaves minor ambiguity about whether databases must be local or whether credentials are needed, but these are not critical for an initial discovery/health check call.

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

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

The tool has zero parameters, so there is no parameter semantics burden on the description. The baseline for no-parameter tools is 4, and the description appropriately focuses on behavior and return value instead.

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 a specific action with a clear resource: discovering running databases and verifying their responsiveness, latency, and socket states. It names the exact database engines covered, which further distinguishes it from generic system health tools among the siblings.

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 this tool is for database health checks by listing supported engines and return details, but it does not explicitly say when to prefer it over siblings like get_system_health or check_service_status. There is no when-not-to-use guidance or mention of 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 supplied, the description carries the safety burden; 'Safley read' and the limitation to 'recent log lines' with a maximum of 1000 convey a read-only, bounded operation. It also discloses the return type as a JSON string. It does not mention error cases or prerequisites, but the core behavioral profile is clear.

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

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

The description is compact, front-loaded with the one-sentence purpose, and organized into Args/Returns sections with no filler. Every sentence contributes useful information.

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

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

For a simple two-parameter read tool with an output schema and no annotations, the description covers purpose, parameter semantics, output format, and operational bounds. Nothing an agent needs to invoke it correctly is 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%, and the description fully compensates: it explains that container_name accepts a name or short/full ID, and that lines_count controls recent-line volume with default and max. This adds meaning well beyond the bare schema properties.

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 a specific verb ('read'), a specific resource ('stdout/stderr logs from a specific Docker container'), and clearly distinguishes itself from siblings like read_service_logs and list_docker_containers. The scope is explicit and immediately actionable.

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 makes clear the tool applies to Docker containers, but it never explicitly says when to choose it over read_service_logs or list_docker_containers, nor does it mention exclusions. Usage guidance is only implied by the tool name and 'Docker container' wording.

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

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

No annotations are provided, so the description carries the burden. It clearly indicates a read-only retrieval operation ('Retrieve', 'Provides', 'Returns') and discloses the return format (JSON string) and the coverage (all running containers, not stopped ones). It does not mention permissions or failure modes, but for a non-mutating stats tool these are minor omissions.

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 written: one sentence for the action, one for the specific metrics and docker-stats equivalence, and one for the return format. Every sentence adds value without repetition or filler.

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 no parameters, no annotations, and an output schema is present, the description is fully sufficient. It states what the tool does, what metrics are included, and what the return looks like. No critical operational context is missing for an agent to invoke it correctly.

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

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

The tool has zero parameters, and the schema is an empty object, so there are no parameter semantics to document. The baseline for zero-parameter tools is 4, and the description correctly avoids inventing 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 uses a specific verb ('Retrieve') and resource ('live resource utilization metrics for all running Docker containers'), and distinguishes itself from sibling tools like list_docker_containers and get_docker_container_logs by stating exactly what it returns: CPU, memory, network, and block I/O metrics. The 'equivalent to docker stats' reference further anchors its purpose.

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

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

The description provides clear context for when to use the tool: when live resource metrics for all running Docker containers are needed. It does not explicitly name alternatives or exclusion criteria, but the scope is unambiguous and no conflicting tool is suggested. This satisfies 'clear context, no 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. It does disclose that the tool returns a JSON string with active jails and banned IPs, which is useful. However, it does not mention whether elevated privileges are needed, how the tool behaves if Fail2ban is not installed, or whether this is strictly read-only.

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

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

Two short sentences with high signal-to-noise ratio. The brief redundancy between 'active protection jails...' and 'active jails and banned IP addresses' is minor and does not harm comprehension.

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

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

With no parameters and an output schema present, the description is largely sufficient for a simple status-check tool. It names the key return content and the tool's focus, though it does not explicitly cover failure modes or privilege requirements.

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

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

The tool has zero parameters, so the description does not need to explain any parameter semantics. The baseline of 4 applies because there is nothing to document.

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

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

Description clearly states a specific action ('Check') and resource ('Fail2ban status, active protection jails, and currently banned IP addresses'). This distinguishes it from sibling tools like check_failed_logins, which focus on login attempts rather than current ban state.

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

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

No guidance is given about when to use this tool versus alternatives such as check_failed_logins or audit_ssh_config. While the purpose is clear, the description does not help an agent choose between overlapping security-related 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, the description carries the behavioral disclosure burden. It discloses that the tool is read-only in nature by using 'Find' and explicitly references systemctl --failed, which is a non-mutating command. It also states the output shape (list of failed units and health indicator). It does not mention permissions or potential limitations, but for a simple diagnostic getter this is reasonably transparent.

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

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

The description is concise and efficiently structured. It leads with the action and scope, then separately provides the return contract. Every sentence adds value, and there is no redundant or filler content.

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

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

For a parameterless read-only diagnostic tool with an output schema, the description is complete. It identifies what is checked, the mechanism (systemctl --failed), and the return components. No additional context is necessary for an agent to invoke or interpret the result.

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

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

The tool has zero parameters, so there is nothing ambiguous for the agent to resolve. The schema already covers everything; the description does not need to add parameter-level meaning. This matches the baseline for a parameterless tool.

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 a specific verb ('Find') and resource ('degraded or failed systemd services') with a clear scope ('across the entire system'). This clearly differentiates from siblings like check_service_status, which targets a single service, and get_system_health, which is broader.

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 a system-wide health check use case, but it does not explicitly state when to prefer this over siblings such as check_service_status or get_system_health, nor does it mention exclusions or alternatives. The 'across the entire system' phrase provides some context, but the guidance is only implied.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states a read-oriented action and the return payload, but does not explicitly confirm it is read-only or note any privilege/permision requirements that could affect a successful call. Some context is added via the expected output, but explicit safety/ide-effect disclosure is missing.

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 compact and well-structured: one action sentence followed by a clear 'Returns' list. It front-loads the core purpose and avoids unnecessary detail, making it easy for an agent to parse quickly.

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

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

For a zero-parameter tool with an output schema, the description covers the essential behavior and return content. The main gap is the lack of an explicit read-only/privilege note, but the verb 'Discover' strongly implies a no-side-effect investigation, so this is a minor omission.

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

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

The tool accepts no parameters, so schema description coverage is trivially 100%. A baseline of 4 applies for zero-parameter tools, and the description appropriately focuses on output semantics rather than parameter 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 uses a specific verb ('Discover') and clear resource ('ll listening network ports (TCP and UDP)') with a defined scope and output. This clearly distinguishes it from sibling tools like test_network_connectivity or get_ufw_status, which serve different purposes.

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

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

No explicit when-to-use guidance is provided. The usage is implied by the action described (inspect listening ports), but there is no mention of alternatives or conditions that would make this tool preferred over others in the sibling set.

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 present, the description carries the full burden for behavioral disclosure. It explicitly states that the tool returns a JSON string and details exactly which categories of data are included, including load averages, I/O counters, and uptime. It does not mention potential error conditions or latency, but for a zero-parameter read-only health snapshot this is reasonably transparent.

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 front-loaded with the core purpose and then uses a scannable bullet list to detail the return contents. Every line adds useful information, and the example uptime format helps clarify the expected shape. No filler or redundancy exists.

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

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

For a tool with no parameters and a rich output schema, the description fully covers what an agent needs to know: what the tool does and what data it returns. The presence of an output schema means the agent can also inspect the exact return structure separately, and the description complements it well.

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

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

The tool has zero parameters, so the description need not explain parameter behavior. The baseline for a no-parameter tool is 4, and the description appropriately focuses on the output rather than input semantics.

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

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

The description opens with a specific verb and resource: 'Retrieve a complete system health snapshot of the Linux VPS.' It enumerates CPU, RAM, Disk, Network, and Uptime, which clearly distinguishes this broad health tool from more targeted siblings like get_top_processes, analyze_disk_usage, or get_docker_stats.

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 purpose is unambiguous enough that an agent can infer when to use it: whenever a broad system health overview is needed. It does not explicitly state when not to use it or name alternative tools, but the 'complete system health snapshot' framing provides clear context without excluding edge 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 clearly describes the operation as a retrieval, documents the sort_by options and limit range, and specifies the return format and fields, making the tool's behavior predictable.

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 compact, well-structured with Args and Returns sections, and every sentence adds relevant information. It front-loads the core purpose and then efficiently covers parameters and output.

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

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

For a two-parameter read-only tool, the description is complete: it defines both parameters, their constraints, defaults, and the return shape. Nothing an agent needs to call it correctly is 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?

The input schema only provides types and defaults, with zero description coverage. The description compensates fully by explaining valid sort_by values ('cpu' or 'memory'), the limit range (1 to 50), defaults, and what data is returned.

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 a specific verb ('Retrieve') and resource ('top resource-consuming processes running on the VPS'), which clearly distinguishes it from sibling monitoring tools. It immediately conveys the tool's scope and purpose.

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

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

The description implies when to use the tool: when you need a ranked list of the most resource-consuming processes on the VPS. However, it does not explicitly name alternatives or state when not to use it, so it stops short of 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?

No annotations are provided, so the description carries the burden of explaining behavior. It discloses that the tool inspects rather than modifies and explicitly states the return format (JSON string with active state, policies, and rules). This is adequate for a simple read-only status tool.

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

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

The description is concise and front-loaded, with the core purpose in the first sentence and return-value details in a clearly separated block. Every sentence adds value without redundancy.

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

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

For a zero-parameter, read-only status tool, the description is complete. It covers what the tool does and what output to expect, and the presence of an output schema reduces the need for further return-value explanation.

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

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

The tool has zero parameters, so the schema already fully covers parameter semantics. The description does not need to add parameter details; a baseline of 4 is appropriate for this no-parameter tool.

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 function: inspecting UFW firewall status and active filtering rules. It identifies a specific resource (UFW firewall) and differentiates itself from sibling tools, none of which target UFW.

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 this tool: any time UFW firewall status, default policies, or active rules are needed. It does not explicitly discuss alternatives, but its unique scope among siblings makes the intended usage unambiguous.

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

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

With no annotations, the description carries the behavioral burden and does well by disclosing exactly which cron sources are audited and the return structure. It does not mention potential permission requirements or failure behaviors, but the read-only nature is clear and the listed audit paths are strong behavioral context.

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 compact and front-loaded: a one-line purpose, a concise list of audited locations, and a clearly formatted return summary. Every sentence adds value with no repetition 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?

For a parameterless tool with an output schema, the description is complete enough: it identifies the system scope, enumerates audit sources, and describes returned fields. It could add a note on required privileges or the contrast with list_systemd_timers, but nothing essential is missing for successful invocation.

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

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

The tool takes zero parameters and the schema coverage is 100%, so the description does not need to clarify parameter meanings. The baseline of 4 applies, and the description appropriately focuses on behavior and output rather than inputs.

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 discovers all scheduled cron jobs on the Linux system, with a specific verb and resource. It enumerates the exact audit locations (/etc/crontab, /etc/cron.d/, /etc/cron.*, user crontabs), making its scope concrete and easily distinguishable from systemd-timer-related siblings.

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 gives clear context for when to use the tool: whenever cron jobs need to be enumerated. It does not explicitly name alternatives or exclusions, but the scope is unambiguous and the 'Discover all scheduled cron jobs' phrasing provides sufficient guidance for a zero-parameter tool.

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 does disclose the permitted directory constraint and the return format, but does not explicitly state side-effect-free behavior or error handling. This partial transparency earns a 4.

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 structured with a clear purpose, a list of permitted directories, parameter explanations, and return format. It is a bit verbose but front-loaded with the main action. No superfluous content; it earns a 4.

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?

Even though there is an output schema (not shown), the description provides sufficient detail about the return format (JSON string with item list including names, types, sizes, modification dates). It also outlines the permitted directory scope. Minor omissions like exact error behavior keep it from a 5.

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

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

The input schema lacks parameter descriptions, but the tool description adds meaningful context: it explains dir_path as 'path to the directory to inspect' and max_depth as 'exploration depth (1 to 3, default: 1)'. It also attaches the critical constraint of permitted directories to dir_path. This significantly enriches the schema.

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

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

The description clearly states the tool's purpose: to inspect file and directory structures within authorized administrative paths. It explicitly lists permitted directories, and the return format (JSON string with item list) confirms it lists directory contents. This is sufficiently specific to distinguish it from 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 mentions 'authorized administrative paths' but does not explicitly state when to use this tool versus alternatives like view_file_content or list_virtual_hosts. An agent may infer usage from the name, but there is no explicit guidance on conditions or exclusions.

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

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

With no annotations, the description carries the full behavioral burden. It clearly signals a read-only 'List' operation and discloses the return shape: a JSON string with containers, port forwards, and mount mappings. It does not mention failure modes or daemon availability, but for a list operation this is adequate.

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

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

The description is concise and well-structured with distinct Purpose, Args, and Returns sections. It leads with the action and resource, contains no filler, and every sentence contributes useful information.

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

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

For a one-parameter, read-only tool with an output schema, the description is nearly complete: it explains the parameter and the return payload. It only lacks explicit context about when to prefer this over related sibling commands, but this is a minor 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?

The schema provides only the boolean name and default, with no property description. The description fully compensates by explaining the True and False behaviors: all containers vs running only. This adds meaningful semantic context beyond the schema.

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

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

The description opens with a specific action and resource: 'List Docker containers', and enumerates the contained fields: status, image, port bindings, volumes, and health. This clearly distinguishes it from sibling tools like get_docker_container_logs or get_docker_stats.

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 tool is simple enough that usage is implied by its name, and the 'all' parameter is explained. However, there is no explicit guidance about when to choose this tool over siblings such as get_docker_stats or get_docker_container_logs.

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

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

With no annotations, the description carries the behavioral burden and it does well by naming the exact systemctl command and stating the return payload fields. It implies a read-only audit operation, though it never explicitly says it makes no system changes or whether elevated permissions are needed.

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

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

The description is two compact sentences: the first states the action and command, the second enumerates the return values. There is no filler or redundant detail, making it easy to scan.

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

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

For a zero-argument read-only auditing tool with an output schema, the description covers the command, scope, and return fields. It could add a note about permissions or how it relates to cron-job auditing, but those are not critical for invoking the tool correctly.

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

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

The tool accepts zero parameters, so there is no parameter semantics to clarify; the baseline of 4 applies. The description's mention of the command and output is sufficient for a no-argument tool.

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 names a specific verb and resource: 'Audit active and pending systemd timers'. It also identifies the underlying command 'systemctl list-timers', making the tool's function unmistakable and naturally distinguishing it from sibling tools like list_cron_jobs.

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

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

There is no guidance on when to prefer this tool over alternatives such as list_cron_jobs or get_failed_systemd_units. The description states what the tool does but not when it should be selected or avoided, leaving that decision entirely to 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?

With no annotations provided, the description carries the disclosure burden. It reveals the return format (JSON string), the source paths (/etc/nginx/sites-enabled/ and conf.d/), and the informational scope. It doesn't explicitly state that the operation is side-effect-free or describe error/failure behavior, so transparency is adequate but not complete.

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

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

Two short sentences contain everything meaningful, with the primary action front-loaded and the return/source information compactly appended. There is no filler or redundant wording.

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

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

For a zero-parameter tool with an output schema, the description adequately covers the source scope and return type. It could note permission requirements or explicitly confirm read-only behavior, but given the simple inspection nature, the description is nearly 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 tool accepts zero parameters and the schema coverage is 100%, so there are no parameter details for the description to add. Baseline 4 is appropriate because no argument documentation is needed.

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 a specific verb (Inspect) and resource (active Nginx virtual hosts), plus relevant aspects like listening ports, SSL, and reverse proxy targets. It doesn't explicitly differentiate itself from siblings such as check_ssl_certificates, get_open_ports, or test_nginx_config, so it falls short of a full 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?

It implies usage whenever Nginx virtual host configuration details are needed, and it names the source paths inspected. However, it doesn't state when to prefer this over sibling tools or mention any exclusions, leaving some selection 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 burder. It conveys read-only intent with 'safely fetch' and reveals the return format as a JSON string with log lines and matching statistics. However, it does not disclose limits, error behavior, or access requirements beyond the line_count cap mentioned in the args.

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 structure is clean: a one-sentence overview, an Args list with per-parameter details, and a Returns statement. Every sentence provides useful information and no filler. The key capability is front-loaded.

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

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

For a three-parameter read tool, the description is self-contained. It covers all parameters with defaults, examples, and constraints, and explains the output shape. Since an output schema exists, the explicit return description is a bonus. Nothing needed to invoke the tool correctly is 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%, and the description fully compensates by documenting all three parameters with meaningful detail: service_name examples ('nginx', 'systemd:cron', 'docker:my_container'), lines_count default 50 and max 1000, and grep_filter as optional and case-insensitive. This far exceeds 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 states a precise verb and resource: 'fetch and optionally filter recent log lines for a service or Docker container.' This clearly communicates the tool's function. It does not explicitly differentiate it from the sibling tool get_docker_container_logs, which may overlap in the Docker case.

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

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

The description implies when to use the tool (to retrieve recent logs, optionally filtered) but provides no explicit guidance about when to choose this over related siblings like get_docker_container_logs or check_service_status. No exclusion or alternative-routing context is included.

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, and it delivers substantive behavior details: direct Python sockets, no shell ping, and exactly which latency stages are measured. It also discloses the return shape. It stops short of noting potential side effects like outbound connections to arbitrary hosts, but those are strongly implied by the TCP/TLS handshake wording.

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 organized and front-loaded: a one-sentence summary, followed by bullet-style Args and a Returns section. Every sentence contributes information and nothing is redundant.

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

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

For a three-parameter network diagnostic without annotations, the description covers the core purpose, parameter constraints, and return format. It does not provide explicit sibling guidance or safety notes, but the output schema exists and the description is otherwise sufficient for correct invocation.

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

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

The input schema has no descriptions for any property, so the description fully compensates. Each parameter gets a human-readable explanation with allowed ranges or defaults: target_host with examples, port with 1-65535 and default 443, timeout_seconds with 0.5-30.0 and default 5.0. This is exactly the semantic information an agent needs beyond the raw JSON 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 opens with 'Benchmark outbound network connectivity and latency using direct Python sockets,' naming a specific verb, resource, and method. It further distinguishes itself by listing the three measured stages (DNS, TCP, TLS) and explicitly noting it does not use shell ping, which separates it from diagnostic siblings.

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 explaining that it benchmarks network connectivity and latency, which gives an agent a clear sense of when it applies. However, it never explicitly states when to prefer this tool over related siblings such as check_dns_health or check_ssl_certificates, nor does it mention exclusions or 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 itself communicates that this tool only tests syntax and does not reload the server, which implies a safe read-only validation operation. It also discloses what the return value contains (validity, exit code, and error messages). This is sufficient behavioral transparency for this tool type.

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 two concise sentences with no filler. The primary purpose is front-loaded and the return-value note is directly relevant to an agent calling the 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?

For a zero-parameter tool with an output schema and a return format described inline, the description is complete. An agent knows exactly what action will be taken and what kind of response to expect.

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

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

The tool has zero parameters and the schema description coverage is 100%, so there is no parameter meaning for the description to add. The baseline for a zero-parameter tool is 4, and nothing more is needed here.

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 tests Nginx configuration for syntax errors using `nginx -t` and explicitly says it does not reload. This gives a specific verb, resource, and scope. It is distinctive enough against the sibling tools, none of which appear to focus on nginx configuration..

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 makes the tool's purpose and non-destructive behavior explicit, so an agent can decide to use it when validating Nginx configuration syntax. It does not name alternative tools or explicitly state when not to use it, but no sibling appears to compete directly.

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 fully carries the burden of behavioral disclosure. It states the operation is safe, read-only, protected against path traversal, limited to specific directories, capped at 200,000 bytes, and returns content, size, and modification timestamp.

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 purpose, permitted directories, safety note, Args, and Returns. It is concise, front-loaded, and every sentence contributes to correct invocation.

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

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

The description covers purpose, scope, parameter semantics, and return shape, making it sufficient for a simple read tool. The main omission is explicit behavior for unauthorized or missing paths, but this is minor given the clear permitted-directory boundaries and 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?

Schema description coverage is 0%, so the description must explain both parameters. It clearly defines file_path as a canonical or relative path and max_bytes with default 50,000 and cap 200,000, adding meaning beyond the raw input 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 reads the content of authorized configuration or web files and lists permitted directories. This makes it easy to distinguish from siblings like list_directory, read_service_logs, and write_file_content.

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?

It gives clear context by enumerating the permitted directories and the file types the tool targets. It does not explicitly name alternative tools for exclusion, but the scope is specific enough for an agent to know when this tool is appropriate.

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

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

With no annotations, the description carries the full burden and uses it well: it discloses atomic write behavior, creation of a timestamped backup before overwriting, optional backup via the backup parameter, authorized directory restrictions, and the JSON return format. The potentially destructive overwrite is revealed with mitigations rather than hidden.

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 compact, front-loaded with the core behavior, and then formatted into scope, parameters, and return sections. No filler sentences; each line adds needed information.

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

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

For a three-parameter mutation tool, the description covers what the tool does, where it may act, what side effects occur, what the parameters mean, and what the caller receives. There is no destructive ambiguity or missing critical input needed to invoke it.

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

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

Schema description coverage is 0%, but the description documents all three parameters with meaningful details: file_path as the target path, content as text to write, and backup with its default behavior. This more than compensates for the barren input 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 opens with a specific verb and resource: 'Atomically write or update a configuration file within authorized directories.' This clearly distinguishes it from read-only siblings like view_file_content and list_directory, and the permitted-directory list narrows its scope further.

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?

It states the tool is for writing or updating configuration files and explicitly enumerates permitted directories, which gives an agent clear conditions for use and exclusion (anything outside those directories). It does not name alternative tools or explicitly say when-not-to-use, but the scope is concrete enough to route selection.

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