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

With no annotations, the description must disclose side effects and operational behavior. It only mentions the challenge type and provider selection, but does not explain that certificate issuance involves external ACME requests, potential waiting time, prerequisites like domain ownership, or that DNS-01 challenges are available for wildcards (as shown in the schema). This leaves significant 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?

Two short sentences, no filler, and the most important usage guidance is front-loaded. Every word adds information.

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

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

Given the tool's complexity (dual modes, nested meta options, external ACME interaction, no output schema), the description is too sparse. It fails to mention support for DNS-01/wildcards, required agreement or email fields, or what a typical response looks like. An agent would need to infer too much from the schema alone.

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

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

The description adds context for the provider parameter (letsencrypt for HTTP-01) and hints at the custom certificate upload path, but it does not elaborate on the meta object fields (dns_challenge, letsencrypt_email, propagation_seconds, etc.) or the domain_names format beyond what the schema already provides. With schema coverage around 50%, the description only partially compensates.

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: requesting a new Let's Encrypt certificate via HTTP-01 challenge or uploading a custom certificate. This distinguishes it from sibling tools like renew_certificate, list_certificates, and delete_certificate by focusing on the creation action.

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

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

The description provides explicit guidance to use provider "letsencrypt" for standard HTTP challenge runs, which indicates when to choose that provider. However, it does not explicitly state when to use a custom certificate or when to prefer the renew_certificate sibling, so it lacks full when/when-not coverage.

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 disclose behavioral traits. It only states the operation ('create a 404 host') without mentioning side effects, idempotency, prerequisites (e.g., certificate requirements), or what happens to existing configurations. This leaves significant behavioral uncertainty.

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

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

The description is a single, front-loaded sentence that conveys the core purpose without any redundant words. It is concise and efficient.

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

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

The tool has five parameters, no annotations, and no output schema. The description is too minimal to provide the necessary context about parameter usage, behavioral implications, or configuration options, making it inadequate for confident invocation.

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

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

Schema description coverage is 0%, and the description only references 'one or more domains' (domain_names). It does not explain the purpose or meaning of meta, enabled, certificate_id, or advanced_config, which remain undocumented for the agent.

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 with a specific verb ('Create') and resource ('404 (dead) host'), and differentiates it from sibling host creation tools (e.g., proxy, stream, redirection) by focusing on dead hosts.

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 the clear use case: creating a host that returns 404 for given domains. It does not explicitly name alternatives or exclusion criteria, but the context is unambiguous enough for an agent to select this tool when a dead host is needed.

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 all responsibility for behavioral context. It omits side effects, prerequisites (e.g., DNS pointing, certificate validity), and the fact that this modifies the NPM configuration. It only teases the purpose without detailing what happens upon creation or what the user needs to ensure beforehand.

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 and front-loaded with the action. Two sentences with no filler, perfectly readable and to the point.

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

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

For a complex tool with 16 parameters, nested objects, and no output schema, the description is severely under-specified. It does not explain return values, prerequisites, or potential pitfalls (e.g., certificate ID handling). The high-level purpose is there but lacks enough contextual depth to be considered 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 schema has only ~25% description coverage, and the description adds no parameter-specific meaning. It does not explain the key fields like forward_host, forward_port, domain_names, or ssl_forced, leaving the agent to guess the roles of the 16 parameters. The description fails to compensate for the schema's low coverage.

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

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

The description clearly states the tool action ('Create a new reverse proxy host') and its intended use ('expose a service via a domain through NPM'). This specific verb-resource combination distinguishes it from sibling tools like creating streams or redirection hosts.

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 provides a clear primary scenario: 'the main way to expose a service via a domain through NPM.' However, it does not explicitly mention alternatives or exclusion cases (e.g., when to use update instead), so it stops short of full 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 burden of behavioral disclosure. It discloses only that the tool creates a forwarding rule, but omits any side effects, requirements (e.g., certificates), reversibility, or response behavior, similar to the update_drive example.

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

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

The description is a single sentence with no filler or redundancy. It front-loads the core purpose and earns its place by stating the primary function concisely.

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

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

This is a complex tool with 10 parameters, 4 required, a nested object, no annotations, and no output schema. The one-sentence description is insufficient to guide correct usage; it does not address certificate handling, response format, or the meaning of advanced options, leaving the agent without critical context.

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

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

Schema description coverage is low (30%), so the description must compensate, but it does not. While 'forwards one domain to another' hints at domain_names and forward_domain_name, it fails to explain critical parameters like forward_scheme, forward_http_code, block_exploits, or advanced_config, adding minimal value 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 clearly states the action (create) and the resource (redirection host) with a specific outcome ('forwards one domain to another'). It distinguishes this from sibling tools like create_proxy_host and create_stream by explicitly naming 'redirection host' as the resource.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios, prerequisites, or when to prefer creating a proxy or stream instead, leaving usage entirely 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states 'Create' without explaining side effects, whether existing streams are affected, if a host must exist first, or what happens on port conflicts. The nested meta.nginx_stream_config is completely unaddressed.

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

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

The description is a single sentence, but it is under-specified for a tool with seven parameters and a nested object. This is not effective conciseness but rather a lack of necessary detail, similar to the 'process' example.

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 (7 parameters, one nested object, no output schema, no annotations), the description provides almost no context. It does not explain return values, required field semantics, or operational behavior, making it inadequate 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?

Schema description coverage is 0%, and the description does not compensate. It mentions TCP/UDP but does not explain the meaning of parameters like incoming_port, forwarding_host, enabled, tcp_forwarding, udp_forwarding, or the meta object, leaving the agent to infer from names alone.

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

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

The description uses a specific verb 'Create' and identifies the resource as a 'TCP/UDP port forward' with the parenthetical '(stream)' clarifying the tool's domain. This clearly distinguishes it from sibling create tools like proxy hosts or redirection hosts.

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

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

No guidance is provided on when to use this tool versus alternatives such as npm_create_proxy_host or npm_create_redirection_host. The description does not mention exclusions, prerequisites, or typical use cases.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It neither states that deletion is permanent nor mentions any side effects, permissions, or irreversible consequences. This is a significant gap for a 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 a single sentence with no filler words. It is appropriately concise for a simple operation, front-loading the action and resource.

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

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

The tool is a simple delete-by-id operation, but the description omits essential context like irreversibility, whether confirmation is needed, or related tools for listing certificates. The lack of annotations and output schema makes the description insufficient for safe usage.

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

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

The schema already defines the 'id' parameter as an integer greater than 0. The description merely repeats 'by id' without adding meaning such as where the ID comes from, how to obtain it, or any formatting details. With 0% schema description coverage, the description fails to compensate.

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

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

The description states the action clearly with a specific verb ('Delete'), the resource ('a certificate'), and the identifier ('by id'). This distinguishes it from sibling tools like renew, create, list, and download.

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 usage guidance is provided. It does not mention when to use this tool versus alternatives, prerequisites, or any caution about the irreversible nature of deletion.

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 is the sole disclosure of behavior. It states the action (delete) but omits any consequences such as irreversibility, required permissions, or cascading effects. For a destructive tool, this is minimal transparency.

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

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

The description is a single, concise sentence that immediately conveys the action, target, and method. Every word is essential, and it is properly 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 simple delete operation with one parameter, the description covers the core purpose. However, gaps remain: no indication of what happens on success or failure, no prerequisites, and no warning about permanence. It is adequate but lacks behavioral context that would be helpful for an agent.

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

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

Schema description coverage is 0%, so the description must clarify the parameter. Saying 'by id' confirms the role of the 'id' parameter but does not explain how to obtain the id (e.g., from a list operation) or any additional meaning beyond the schema's integer type.

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

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

The description clearly states the action ('Delete') and the specific resource ('404 (dead) host') and identifies how the host is referenced ('by id'). This distinguishes it from sibling delete tools like npm_delete_proxy_host or npm_delete_redirection_host by specifying the exact target type.

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 use for deleting dead hosts, but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions. The reader must infer usage from the tool name and description alone.

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

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

No annotations are provided, so the description must fully disclose behavior. It only states the action but does not reveal whether deletion is permanent, whether it fails if the host is in use, any side effects on related resources (streams, redirections), or required permissions. This is a significant gap for a 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 a single sentence, 'Delete a proxy host by id,' with every word contributing meaning. It is highly concise and front-loaded, with no wasted text or irrelevant details.

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

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

The description lacks essential context for a destructive tool with no output schema or annotations. It doesn't state what happens on success (e.g., return value), whether the operation is reversible, or any preconditions. For a simple one-parameter delete, it misses the opportunity to clarify expected outcomes and edge cases.

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

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

The schema has one parameter 'id' with no description (0% coverage). The tool description only says 'by id', which adds minimal meaning (that id is the proxy host identifier) but does not explain the expected format, how to obtain it, or any constraints beyond the schema's integer/exclusiveMinimum. The description does not compensate for the lack of schema documentation.

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

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

The description 'Delete a proxy host by id' uses a specific verb (delete) and resource (proxy host), clearly distinguishing it from sibling tools like create, update, enable, disable, or get. It is immediately obvious 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 no explicit guidance on when to use delete versus alternatives such as disable (which might be a non-destructive option) or the broader context of proxy host lifecycle. It implies usage through the verb but doesn't 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 carries the full burden of behavioral disclosure. It only says 'Delete' and does not mention irreversibility, permissions, side effects, or error conditions. This is minimal transparency for a 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 a single concise sentence, front-loaded with the action and resource. It contains no filler or unnecessary detail, earning a high score for conciseness.

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?

Despite the simple nature of the tool, the lack of annotations and output schema means the description should provide more context, such as whether the delete is permanent, what happens if the id does not exist, or any return value. It is under-specified.

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

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

Schema description coverage is 0%, so the description must compensate. It only repeats the parameter name 'id' without adding meaning beyond the schema. There is no explanation of what the id refers to, constraints, or behavior on invalid input.

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 'Delete' and a specific resource 'redirection host', and clearly indicates the parameter 'by id'. This distinguishes it from sibling tools like create/update/list redirection hosts.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or contrast with update/list operations. The usage is only implied by the action verb 'Delete'.

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 only states the action ('Delete') without mentioning side effects, permanence, permissions, or associated data impact. For a destructive operation, this is a significant gap.

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

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

The description is a single, concise sentence with no unnecessary words. It is front-loaded and easily parsable.

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 destructive operation with no annotations and no output schema, the description provides only the basic act and parameter. It lacks information about irreversibility, required permissions, or error handling, making it incomplete for an AI agent to fully understand the tool's behavior.

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

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

The description says 'by id', which clarifies that the 'id' parameter identifies the stream to delete. However, with 0% schema description coverage, it adds minimal value beyond the parameter name and does not explain where to obtain the id or what happens with invalid/unknown ids.

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 'Delete' plus the resource 'stream' and the parameter 'id', clearly identifying the tool's action. It distinguishes itself from sibling tools that operate on other resources like proxy_hosts or dead_hosts.

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 that the tool is used when you want to delete a stream by its id, but it does not explicitly state when to use it over alternatives or exclude any cases. Since there is no alternative for deleting streams among the listed siblings, the context is clear enough but 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?

No annotations are provided, so the description must fully disclose behavior. It only states 'Disable' and 'without deleting it', which hints at non-destructiveness but does not explain side effects (e.g., what happens to traffic, whether the host can be re-enabled, or whether the operation is reversible). The description is too sparse to understand the implications of disabling.

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

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

The description is a single, front-loaded sentence that delivers the core action and a key clarification in a compact format. Every word earns its place, and there is no unnecessary verbosity.

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

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

Despite the simple interface (one parameter), the lack of annotations and output schema place the burden on the description. It does not explain what 'disabling' entails, whether there are error conditions, or how the id is used. The tool is minimally described but leaves critical behavioral and usage context ambiguous.

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 one required integer 'id' with 0% description coverage. The description does not mention the 'id' parameter at all, leaving the agent to infer that it identifies the proxy host. Given low schema coverage, the description fails to compensate by explaining the parameter's meaning or constraints.

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 with a specific verb ('Disable') and resource ('proxy host'), and explicitly distinguishes from deletion with '(without deleting it)'. This differentiates it from sibling tools like npm_delete_proxy_host and sets expectation for non-destructive behavior.

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 'without deleting it' implies a use case where the host should be temporarily disabled rather than removed, but there is no explicit guidance on when to choose this over enable/delete. It lacks criteria such as 'use this to stop traffic while preserving configuration' or mention of prerequisites.

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, but it does not specify whether this is a read-only operation, the response format, required permissions, or error behavior. The agent must guess at the tool's safety and side effects.

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

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

The description is a single, direct sentence with no redundant words. It front-loads the primary verb and resource, making it scannable.

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 tool has no output schema and no annotations, yet the description is extremely minimal. It does not explain what 'Download' returns (e.g., file content versus path), nor does it address prerequisites, validation, or edge cases. This incompleteness could lead to incorrect 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 covers 'format' with a description and enum, and the tool description echoes the variants (pem, key, chain) without adding new meaning. The 'id' parameter is undocumented in both the schema and description, leaving its purpose unclear. With only 50% schema coverage, the description does not adequately compensate for the missing id explanation.

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 ('Download') and the specific resources ('certificate', 'private key', 'chain'), with the format distinction explicit. It differentiates the tool from sibling tools like create/renew/delete by focusing on retrieval.

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

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

The description implies usage through the verb 'Download' but provides no explicit when-to-use guidance or comparisons to alternatives. There is no mention of contexts where a sibling tool would be preferred, so the guidance is purely inferred.

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

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

With no annotations, the description carries full responsibility for disclosing behavioral traits, but it only states the action itself. It does not mention side effects, idempotency, permissions, or what happens if the host is already enabled.

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

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

The description is a single, focused sentence with no extraneous words. Every word contributes to the meaning, making it highly concise and well-structured.

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

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

For a state-changing operation with no annotations and no output schema, this description is too minimal. It lacks context about expected behavior, error conditions, or prerequisites, leaving the agent with only the literal action to rely on.

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 provides no information about the 'id' parameter. The parameter's meaning is inferred from the tool name and schema (positive integer proxy host ID), but the description does not explicitly compensate for the missing schema documentation.

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

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

The description uses a specific verb 'enable' and resource 'proxy host', and explicitly targets 'disabled' hosts, distinguishing this from sibling operations like disable, update, or create.

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 is implied by the word 'disabled' – this tool is for re-enabling a proxy host that was previously disabled – but there is no explicit guidance on when to use it vs alternatives, nor any exclusions or prerequisites mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get', which implies a read operation, but does not describe return format (e.g., object shape), error behavior (e.g., 404 if not found), or any side effects. It adds no context beyond the verb, so transparency is low.

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 one concise sentence that is front-loaded and free of unnecessary details. For a simple getter, this level of conciseness is appropriate and efficiently communicates the core function.

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

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

Given the simplicity of a single-get operation, the description covers the essential purpose. However, there is no output schema to explain the return value, and the description does not define what happens if the id does not exist, leaving some incompleteness. It is adequate but lacks richer context that would make the tool fully self-contained.

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. The phrase 'by id' confirms that the single parameter is the identifier of the proxy host, but this adds minimal meaning since the parameter is already named 'id' and the tool is named 'get_proxy_host'. It does not explain the integer constraint, formatting, or how to obtain the id, so compensation is weak.

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 'Get a single proxy host by id' clearly states the action (get), the resource (proxy host), and the scope (single by id). This distinguishes it from sibling tools like npm_list_proxy_hosts (which retrieves all) and npm_create_proxy_host/update/delete (mutations).

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

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

The description implies usage when you need a specific proxy host by id, but it does not explicitly state alternatives or exclusions. It lacks guidance on when to use this tool versus npm_list_proxy_hosts or other getters, making the usage guidelines implied rather than explicit for an 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, the description carries the full burden of behavioral disclosure. It only states the basic operation and adds no context about return format, error handling, or permissions. For a get operation this might be sufficient, but the description leaves the agent without critical behavioral details.

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

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

The description is a single sentence with no filler, front-loaded with the verb and resource. It is maximally concise while retaining clarity.

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

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

The tool is simple (one parameter, no output schema), and the description provides the basic idea. However, it omits the return value and error behavior, which are important for an agent to know before invocation. It is minimally viable but has clear gaps.

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

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

The schema has one required integer 'id'. The description merely repeats 'by id' without adding meaning about how to obtain the ID, valid range, or relationships. With schema description coverage at 0%, the description fails to compensate and adds no value beyond the property name.

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 ('get'), resource ('stream'), and scope ('single by id'), which distinguishes it from list_streams. It is specific and unambiguous.

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

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

The description implies usage—when you have a specific stream ID—but does not explicitly mention alternatives like list_streams or describe when not to use it. This is implied usage rather than 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. 'Get' implies a read-only operation, but the description fails to disclose what happens when the id does not exist (e.g., returns null or 404), whether the response is the full user object, or any auth/rate-limit considerations. For a tool with no safety annotations, this is a notable gap.

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

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

The description is a single sentence, front-loaded with the action and resource. Every word earns its place with no filler or redundancy. This is the ideal size for a simple getter 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?

The tool is simple with one required param and no output schema, so the description is mostly adequate. However, it lacks any mention of return value, error behavior, or not-found cases. Given there is no output schema and no annotations, a bit more context would improve completeness. It is not egregiously incomplete but has clear gaps.

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

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

The schema fully defines the single parameter 'id' with type and constraints (integer > 0). The description adds only 'by id', which is marginal. Since the schema already provides complete parameter details, the low schema description coverage (0%) is not a practical issue, but the description does not enrich the semantics 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 clearly states the verb 'Get' with a specific resource ('a single user') and key qualifier 'by id'. It directly contrasts with the sibling tool 'npm_list_users', making it unambiguous which tool to use for fetching one user.

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 'by id' implicitly indicates that this tool is appropriate when you have a specific user ID, and that list tools should be used otherwise. However, it does not explicitly mention alternatives or exclusions. For a simple getter, this is adequate but not fully explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It adds only 'recent' without defining the timeframe, sort order, or output structure. It also does not explicitly confirm the operation is read-only, though 'list' implies it.

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

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

The description is a single sentence with no wasted words. It front-loads the action and resource, making it immediately clear what the tool does.

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?

Despite the tool's simplicity, the description leaves important questions unanswered: what counts as 'recent', what fields are included in the audit log entries, whether pagination is supported (though the schema implies it), and any access requirements. With no output schema and no annotations, the description is too thin.

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 0% description coverage for its two parameters, and the tool description does not mention page or count at all. The schema provides defaults and constraints, but the description adds no meaning beyond the parameter names.

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 lists recent audit log entries, using a specific verb and resource. It is distinct from sibling list tools like npm_list_users or npm_list_proxy_hosts, which target other resource types.

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

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

There is no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The only cue is the tool name itself, which implies the audit log but does not explain when it should be chosen over other list tools.

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

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

No annotations are provided, so the description carries the full burden. It clearly indicates a read-only operation via 'List', and specifies the scope (all SSL certificates, including Lets Encrypt and custom). However, it does not mention any permissions, return format, or potential side effects. It is minimally transparent but not misleading.

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

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

The description is a single, concise sentence: 'List all SSL certificates (Lets Encrypt and custom).' It is front-loaded with the verb and resource, contains no unnecessary words, and fully communicates the tool's function.

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

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

For a no-parameter list tool with no output schema, the description is sufficient for invocation. It states what the tool does and the scope. It could optionally mention return details (e.g., certificate details like expiry), but this is not essential for correct use. Overall, it is adequately 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 input schema has 0 parameters, so the baseline is 4. The description does not need to explain parameters since there are none. It adds no parameter-related information, but no compensation 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 uses the specific verb 'List' with the resource 'SSL certificates' and specifies scope 'all' with 'Lets Encrypt and custom', clearly distinguishing it from sibling tools like npm_create_certificate, npm_renew_certificate, etc. This is a clear and specific statement of 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. Usage is implied by the name and description (to list certificates), but there is no mention of when not to use it or mention of alternative tools. This 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 of behavioral disclosure. It merely states 'List all...' which implies a read operation, but it does not disclose any potential side effects, authentication requirements, rate limits, or output details. This is insufficient for a tool without annotation support.

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

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

The description is a single, information-dense sentence with no filler or repetition. It is appropriately concise for a tool with no parameters.

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

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

Given the tool's simplicity (zero parameters, no output schema), the description is largely complete in stating its purpose. However, it lacks any notes on return format, pagination, or edge cases, which would enhance completeness. Since it is a basic listing tool, 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 input schema has zero parameters and 100% schema coverage, establishing a baseline of 4. The description correctly omits parameter details since there are none, and it does not need to compensate for any schema gaps.

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

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

The description 'List all 404 (dead) hosts' uses a specific verb and resource, clearly identifying the tool's function. It distinguishes from sibling tools like npm_list_redirection_hosts and npm_list_proxy_hosts by naming the specific resource type (dead hosts).

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool name and description.

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?

There are no annotations, so the description must carry the behavioral disclosure. It only says 'List all', which hints at scope but provides no details on return format, pagination, authorization requirements, or whether disabled hosts are included. This is minimal behavioral information.

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

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

The description is a single, clear sentence with no wasted words. It is front-loaded with the action 'List' and the resource immediately follows. Perfectly concise.

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 list operation with no parameters and no output schema, the description is adequate but not thorough. It does not mention what fields are returned or any limiting behaviors. Given the lack of an output schema, a bit more detail on the return value would improve completeness.

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

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

The tool has zero parameters, and the schema is empty with complete coverage. The description correctly adds nothing about parameters. Per the rubric, a baseline of 4 is appropriate 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 uses the specific verb 'List' and identifies the exact resource: 'Nginx Proxy Manager proxy hosts (reverse proxies)'. This clearly distinguishes it from sibling tools like npm_list_redirection_hosts and npm_list_dead_hosts.

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 context is clear: use this to list all proxy hosts. It does not explicitly mention alternatives like npm_get_proxy_host for a single host, but the description and name make the use case obvious. No exclusions or prerequisites are stated.

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

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

With no annotations, the description carries the burden. The verb 'list' clearly indicates a read-only operation, which is a behavioral trait. However, it does not disclose return format, sorting, pagination, permissions, or side effects, so transparency is limited but adequate for a simple list 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?

A single sentence, 'List all redirection hosts,' is concise and front-loaded with the action and object. No wasted words, and the structure is optimal for a tool with no parameters.

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

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

For a zero-parameter, no-output-schema list tool, the description is nearly complete. It states the exact action and object. The only minor gap is not specifying the return structure (e.g., array of objects), but this is often inferred and doesn't hinder selection or 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 has zero parameters, so the schema fully defines the input. The description doesn't need to explain parameters, and none are missing. Baseline for zero-parameter tools is 4, and no deduction 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 'List all redirection hosts' uses a specific verb ('list') and resource ('redirection hosts'), clearly distinguishing it from siblings like npm_list_proxy_hosts and npm_list_streams. The word 'all' clarifies scope, leaving no ambiguity about what is returned.

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 is implied by the tool name and description: use when you need to see all redirection hosts. However, there is no explicit guidance on when to choose this over alternatives, nor mention of prerequisites or exclusions. It meets the minimum viable bar but adds no extra context.

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. 'List all' clearly indicates a read-only, non-destructive operation. However, no additional behavioral details are provided, such as output format, ordering, pagination, or authentication requirements, so transparency is only partially addressed.

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

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

The description is a single, front-loaded sentence that states the action and resource directly. It is extremely concise with no wasted words or redundant information.

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

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

For a simple list tool with no parameters and no output schema, the description adequately defines the scope ('all TCP/UDP stream port forwards'). It lacks details about return format or potential filtering, but given the low complexity, it is mostly 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 has 0 parameters and an empty schema. Baseline for 0 params is 4. The description adds no parameter details because none are needed; it correctly implies no inputs are required.

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

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

The description clearly states the action (List) and the resource (all TCP/UDP stream port forwards), which distinguishes it from sibling tools like npm_get_stream (specific stream) and other list tools for different resources. The scope 'all' is explicit.

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

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

The description implies usage for retrieving all streams but provides no explicit guidance on when to use it versus alternatives such as npm_get_stream. No exclusions or alternative tool references are given, so the context 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 disclosing behavior. It only states the basic action ('List all NPM users') without mentioning read-only nature, authentication requirements, response format, or potential large result sets. The verb 'list' implies read-only but this is not explicit.

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 one short, clear sentence with no wasted words. It directly states the action and target, making it highly efficient and easy to parse.

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

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

For a zero-parameter tool with no annotations or output schema, the description is largely complete. It tells the agent exactly what the tool does. However, a bit more context about the nature of 'NPM users' or the response format would make it fully self-contained, so it is not a perfect 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 tool takes no parameters, so the description does not need to explain parameter meanings. The baseline for zero params is 4, and the description correctly provides no unnecessary parameter information.

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 ('List') and resource ('all NPM users'), clearly distinguishing it from sibling tools like npm_get_user which presumably fetches a single user. The phrase 'List all' unambiguously conveys the scope.

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

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

There is no guidance on when to use this tool versus alternatives such as npm_get_user or npm_raw_request. No context is provided about typical use cases, prerequisites, or situations where this tool would be preferred.

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 states the tool 'verifies reachability,' implying a non-destructive read-only action, but it does not disclose what happens when unreachable or what the response format is. This is minimally adequate for a simple health check.

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

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

The description is a single concise sentence, front-loaded with the key term 'health check.' Every word contributes meaning, and there is no 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 tool with no parameters, no output schema, and no annotations, the description adequately conveys its purpose and usage. It could mention what a reachable/unreachable result looks like, but the tool is straightforward enough that this is not a critical 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 tool has zero parameters, and the schema is empty with 100% coverage vacuously. Per the rubric, 0 parameters gives a baseline of 4; the description does not need to explain 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 ('verify') and resource ('NPM instance'), clearly stating it is a health check for reachability. This distinguishes it from the sibling CRUD tools, which focus on managing specific resources.

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 clear usage: use this tool to verify NPM instance connectivity before performing other operations. It provides clear context without explicit exclusions or alternatives, which is appropriate given no sibling health-check tools exist.

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. It discloses that requests are 'authenticated' and that query/body are 'JSON-encoded', which is useful. However, it does not state what the response looks like, whether responses are pass-through, or any side effects beyond what the HTTP method implies, leaving a notable transparency gap.

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

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

Three sentences, each earning its place: purpose, path example, and parameter handling. No fluff, front-loaded with the key concept 'Escape hatch', and entirely readable in a single glance.

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

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

Given that this is a generic raw request tool with no output schema, the description covers the essentials: authentication, path, method, query, and body. It does not explain the response format or error behavior, but for an escape hatch that presumably passes through the API response, this is a minor omission rather than a critical 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 only documents 'path', but the description adds crucial meaning: an example path ('/api/nginx/proxy-hosts'), that method must be upper-case, and that query and body are objects that get JSON-encoded. This compensates for the schema's low 25% coverage and clarifies how to use the parameters.

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

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

The description clearly states it is an 'Escape hatch' to 'send any authenticated request to the NPM API', which is a specific verb+resource. It distinguishes from the many sibling tools by being the generic raw-request fallback, unlike the specialized list/create/update/delete 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 'Escape hatch' label implies it should be used when no other sibling tool fits a need, which is clear guidance. It provides an example path and explains that method is upper-case and query/body are JSON-encoded, but it does not explicitly name alternative tools or describe when not to use it.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'renew (re-request)' without noting side effects, authorization requirements, whether it replaces the certificate, or potential failure modes. This lack of context is insufficient for a 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 a single concise sentence with no redundant words. It gets straight to the point, making it highly efficient and 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?

Given the lack of annotations and output schema, the description should cover essential behavioral aspects. It does not mention what happens after renewal, whether the operation is synchronous, or any prerequisites. The one-liner leaves significant gaps for a tool that modifies a certificate.

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 one parameter 'id' with no description. The description clarifies that 'id' refers to an existing Lets Encrypt certificate, which adds meaning beyond the raw schema. However, it provides no additional details about the id's format or how it should be obtained.

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 the specific verb 'Renew' and targets a clear resource: 'an existing Lets Encrypt certificate by id.' This distinguishes it from sibling tools like create, delete, and download certificate. The action 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of conditions (e.g., expiration) or explicit alternatives like 'Use npm_create_certificate for new certificates.' The word 'existing' implies a distinction, but it does not actively guide selection.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies partial-update semantics ('Provide only fields to change') but does not specify whether omitted fields are preserved, whether changes are reversible, or what the response contains. The tool could overwrite the entire host configuration, and this ambiguity is a significant gap.

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

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

The description is a single sentence that is front-loaded with the core action and resource. It avoids unnecessary wording and is appropriately concise for a simple update 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?

Despite having 5 parameters and no annotations, the description provides minimal context. It lacks details about the required 'id', the meaning of specific fields, success/failure responses, and any side effects. While it conveys the basic purpose, it is incomplete for a tool of this 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 has 0% description coverage, so the description must compensate. It adds the key semantic that the optional fields are the ones to change, which is valuable. However, it does not explain each parameter (e.g., certificate_id, advanced_config) beyond their names, and the 'id' parameter is not explicitly mentioned as the target selector, though it is in the schema.

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

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

The description clearly states the action ('Update') and the resource ('a 404 (dead) host'), which distinguishes it from sibling tools like npm_create_dead_host, npm_delete_dead_host, and npm_list_dead_hosts. The parenthetical '(dead)' clarifies the type of host being updated.

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: it is for updating an existing dead host, and the instruction 'Provide only fields to change' signals that this is a partial-update operation. However, it does not explicitly state exclusions or alternative tools, such as when to use create or delete instead.

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. It usefully discloses PATCH-like partial-update behavior. However, it does not mention response format, error cases, or any side effects, leaving some behavioral gaps for a mutating 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?

Two concise sentences, front-loaded with the purpose, and no wasted words. Every sentence adds value.

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 16 parameters, no annotations, and no output schema, the description is fairly thin. The partial-update hint is valuable, but return behavior and more detail on required fields are absent. It is minimally viable if paired with the schema.

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

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

Schema description coverage is 0%, and the description does not explain individual parameters. The general rule 'Provide only fields you want to change' helps frame parameter usage, but it does not compensate for 16 undocumented parameters. The agent must rely on field names and types.

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

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

The description clearly states the tool's purpose with a specific verb and resource: 'Update an existing proxy host.' It also distinguishes from sibling tools like create/delete/get by implying mutation. The additional 'Provide only fields you want to change' clarifies partial-update semantics.

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?

Provides clear usage context: you update an existing host and only supply changed fields. It does not explicitly mention alternatives or when-not-to-use, but the sibling tool set and the word 'existing' make appropriate usage inferable.

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 disclosing behavior. It communicates partial-update semantics via 'Provide only fields to change,' which is useful. However, it does not mention side effects, permission requirements, or what happens if the id does not exist. This leaves some gaps in behavioral transparency.

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

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

The description is two short sentences, front-loaded with the core purpose. There is zero extraneous text, and every word contributes to understanding the tool's function.

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

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

For a tool with 10 parameters, no annotations, and no output schema, this description is sparse. It does not mention the required id field, return values, or any prerequisites/effects. While the update nature is clear, the description is insufficient for an agent to fully understand the operational context.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It provides no details about the 10 parameters other than implying that only fields to change need be provided. Parameter names are self-explanatory to some degree, but the description adds no semantic value beyond the schema's types and constraints.

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: 'Update a redirection host.' This distinguishes it from sibling tools like create_redirection_host and delete_redirection_host. The phrase 'Provide only fields to change' reinforces the update semantics.

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

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

The description implies usage context: it is for modifying an existing redirection host rather than creating or deleting one. It provides guidance on how to use the tool ('Provide only fields to change'), but does not explicitly mention alternatives or exclusion scenarios. The context is clear enough, though it could be more explicit about when to use this over similar update tools for other resource types.

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?

The description adds one behavioral trait: partial update semantics ('Provide only fields to change'). With no annotations, this is useful, but it leaves out other behavioral aspects like authorization, return value, or side effects.

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, front-loaded with action, no filler. Every word contributes value.

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 basic operation and partial update rule, but lacks information about return values, error handling, or prerequisites, which is important for a 7-param update tool with no output schema or annotations.

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

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

The description provides a general rule for parameter usage: only fields to change should be supplied, making all optional parameters PATCH-style. However, it does not explain individual parameter meanings, though schema property names are self-descriptive.

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 'Update' with a clear resource 'existing stream', distinguishing it from sibling tools like create_stream or delete_stream. It directly states the action and scope.

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

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

The description clearly indicates the tool is for modifying an existing stream, which is distinct from creating or deleting. It does not explicitly name alternatives, but the context is clear from the sibling list and the instruction to provide only changed fields.

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