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

No annotations are provided, so the description carries the full behavioral burden, and it only implies mutation via 'Create'. It does not disclose whether names must be unique, what happens on duplicate name, required permissions, or what the response contains. For a write tool with zero annotation coverage 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?

A single front-loaded sentence with no wasted words; the verb and resource lead immediately. It is efficient, though arguably too terse to fully earn its place as the only prose an agent gets.

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 5-parameter mutation tool with no annotations and no output schema, so the description should say more about return values, defaults (pass_auth, satisfy_any), and error conditions. With nested array-of-object parameters and no guidance beyond the schema, the definition is under-specified for its complexity.

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

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

Schema description coverage is 100%, so all five parameters are already documented, and the description merely restates that auth users and IP restrictions are the two content categories. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description names a specific verb (Create) and resource (access list) and adds the scope of what the list can hold (HTTP Basic Auth users and/or IP restrictions), which maps directly to the `items` and `clients` parameters. It is clearly distinguishable from npm_list_access_lists, npm_update_access_list, and npm_delete_access_list, though it does not explicitly say so.

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 create a new access list versus updating an existing one, and no note about prerequisites such as needing an existing proxy host to attach it to. The agent must infer the entire usage context from the sibling list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose that this triggers network calls to a CA, may wait for DNS propagation (propagation_seconds), requires DNS provider credentials, or has failure/timeout semantics. 'Request' hints at asynchronous fulfillment but nothing is 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?

A single short, front-loaded sentence with no waste. Brevity is appropriate, though it comes at the cost of behavioral detail.

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 annotations, no output schema, and 8 parameters, the description is too thin. It omits prerequisites (DNS provider credentials, propagation timing), the distinction between HTTP and DNS challenges, and any note on provider scope beyond Let's Encrypt.

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

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

Schema description coverage is 100%, so the schema fully documents all 8 parameters, giving a baseline of 3. The description adds no parameter guidance 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?

States a specific verb+resource: 'Request a new ... SSL certificate'. Clearly distinguishes creating from renew_certificate/list/get/delete siblings. However it narrows scope to 'Let's Encrypt' while the provider param supports 'other', so the stated purpose is narrower than the tool's actual capability.

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?

Implicitly a create operation, and sibling names like npm_renew_certificate and npm_test_http_challenge suggest alternatives, but the description offers no explicit when-to-use guidance, prerequisites, 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, the description carries the full burden of behavioral disclosure but only hints that a dead host answers 404. It says nothing about permissions/auth required, side effects, whether DNS/SSL needs configuring, or the response shape — significant gaps for a create/mutation 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 short, front-loaded sentences with no filler; the core purpose leads. The second sentence is mildly redundant with the advanced_config schema entry, keeping it just short of a 5.

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?

Parameters are fully covered by the schema and no output schema is needed, but for a create tool with zero annotations the description should say more about side effects, required permissions, and relationships to certificates/proxy hosts. It is adequate but leaves real gaps.

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

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

Schema description coverage is 100%, so the schema already documents all seven parameters; baseline 3 applies. The one sentence on advanced_config merely restates the schema field rather than adding format or syntax guidance.

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+resource ("Create a new 404 dead host") and the verb form cleanly separates it from the list/get/update/delete/enable/disable dead-host siblings. It's clear what the tool does without opening the schema, though it doesn't explicitly name how it differs from e.g. npm_create_proxy_host.

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 when-to-use guidance, no prerequisites (e.g. whether a certificate or proxy host must exist first), and no mention of the alternative host types (proxy/redirection/stream) an agent might choose instead. The agent must infer all of this.

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 behavioral burden, yet it only notes that advanced_config and per-location advanced_config are supported. It says nothing about permissions/auth requirements, whether the operation is idempotent or fails on duplicate domains, side effects, or what is returned (e.g., the new host id).

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 the core action, with no filler. The second sentence is slightly redundant in mentioning advanced_config twice, but it usefully surfaces the nested locations capability.

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 comparatively complex 17-parameter creation tool with no annotations and no output schema, the description is thin: it omits required-field context, defaults, and return value. The rich schema partly compensates, but the description should say more to be 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?

Schema description coverage is 100%, so the schema already documents all 17 parameters, making 3 the baseline. The description adds only a marginal note about advanced_config and locations, without clarifying the interplay of the many networking/SSL options beyond what the schema states.

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?

States a specific verb and resource ('Create a new proxy host in Nginx Proxy Manager'), which distinguishes it cleanly from npm_update_proxy_host, npm_delete_proxy_host, and the list/get siblings. However, it never explicitly names an alternative or contrasts its role, so it falls 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 offers no when-to-use or when-not-to-use guidance and no prerequisites (e.g., whether a certificate or access list must exist first). It simply asserts what the tool does, leaving the agent to infer that this is the creation path versus update.

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 says only that a host is created and that advanced_config injects custom nginx config; it does not disclose required permissions, side effects (e.g., whether a certificate is auto-provisioned), duplicate-domain behavior, or what the call returns on success/failure.

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 the core action, with no filler. The second sentence is nearly redundant with the schema's advanced_config description, which is the only minor waste.

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

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

A 12-parameter mutation tool with no annotations and no output schema needs more from its description than two sentences. It omits validation constraints (forward_http_code 300-308), the four required fields, auth/permission needs, and any notion of the returned resource.

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

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

Schema description coverage is 100%, so all 12 parameters are already documented, including advanced_config itself as 'Custom nginx configuration'. The description's mention of advanced_config adds no meaning beyond the schema, so the baseline 3 applies.

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?

States a specific verb and resource: 'Create a new redirection host.' That is unambiguous and the resource type ('redirection host') separates it from the create_proxy_host / create_dead_host / create_stream siblings by name. It stops short of explicitly contrasting itself with those siblings in the description text.

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 on when to use this versus update_redirection_host, create_proxy_host, or create_dead_host, and no prerequisites or preconditions (e.g., certificate must exist, domain must not already be taken). The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation but says nothing about whether the stream is created enabled or disabled, port-availability constraints, certificate/SSL implications despite certificate-related parameters, or what happens on conflict.

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 front-loaded sentence with zero filler, so it is efficient. It is arguably too terse for a seven-parameter mutation tool, but by the conciseness criterion there is no waste.

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

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

For a seven-parameter mutation tool with no annotations and no output schema, the description omits the lifecycle context (created enabled or disabled), SSL/certificate behavior, and any interaction with the existing stream tooling. It leaves the agent under-equipped to call it correctly beyond the required fields.

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

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

Schema description coverage is 100%, so all seven parameters including SSL domain names, certificate_id, and TCP/UDP forwarding flags are already documented in the schema. The description adds no syntax, default, or constraint detail beyond it, making the baseline 3 appropriate.

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?

States a specific verb (Create) and resource (TCP/UDP stream proxy), which is clear enough to distinguish from npm_create_proxy_host or npm_create_redirection_host. However, it never explicitly names the sibling or explains how a 'stream' proxy differs from a 'proxy host'.

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 stream creation versus HTTP proxy host or redirection host creation, and no prerequisites or follow-up steps (e.g., enable_stream) are mentioned. The agent must infer usage entirely from the name.

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 behavioral burden. It states the operation is a creation, but does not disclose required permissions, handling of duplicate users, password behavior, side effects, or what happens to disabled/role fields.

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 single sentence is front-loaded and free of wasted words, but for a tool with six parameters and no annotations it is too terse to be considered well-structured. It is concise without being adequately informative.

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 mutation tool with no annotations and no output schema, the description is incomplete. While the input schema covers parameter details, the description omits behavioral context, permissions, and post-create effects that an agent would need to invoke it safely.

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

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

Schema description coverage is 100%, so the schema already documents every parameter, including required fields. The description adds no additional meaning, constraints, or syntax beyond what the schema provides, making the baseline score of 3 appropriate.

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-resource pair: 'Create a new Nginx Proxy Manager user.' This clearly distinguishes it from sibling operations like npm_update_user, npm_delete_user, and npm_list_users. It does not explicitly name or compare itself to those alternatives, so it falls short of the highest clarity level.

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, when not to use it, prerequisites, or alternatives. The description only says what it creates, leaving all usage context 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?

No annotations are provided, so the description carries the full behavioral burden. It says 'Delete' but never states that the operation is irreversible, whether it cascades to associated hosts/rules, whether it requires admin auth, or what the response looks like on success. For a destructive tool with zero annotation coverage this is a significant gap.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though the extreme brevity reflects missing information rather than deliberate concision.

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 delete with no annotations and no output schema, the description is too thin: it omits irreversibility, authorization requirements, and any failure modes. An agent has enough to identify the tool but not enough to invoke it responsibly.

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

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

Schema description coverage is 100% and the sole parameter list_id is fully documented in the schema itself. The description adds no syntax, range, or format detail beyond what the schema already provides, so baseline 3 is appropriate.

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 (Delete) and resource (access list) and pins the operation to an ID, so an agent can tell it apart from the sibling delete_* tools by resource type. It does not, however, explicitly differentiate itself from npm_list_access_lists, npm_get_access_list, or npm_update_access_list beyond naming 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?

There is no when-to-use guidance, no note that this is the destructive counterpart to create/update access lists, and no indication of prerequisites (e.g. whether the list must be unreferenced before deletion). The agent must infer all of this from the name alone.

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

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

No annotations are provided, so the description carries the full burden. 'Delete' signals a destructive mutation, but the description says nothing about irreversibility, whether a certificate still referenced by a proxy host can be deleted, required permissions, or failure 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?

A single, front-loaded sentence with no filler; the destructive verb leads and the lookup key follows immediately. Nothing is wasted.

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 tool with no annotations and no output schema, the definition is too thin: an agent cannot tell whether deletion is reversible, blocked by dependents, or permission-gated. The parameter is covered, but the behavioral envelope is not.

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

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

Schema description coverage is 100% and the single parameter is fully documented as 'The ID of the certificate to delete'. The description's 'by ID' phrase adds nothing beyond the schema, so the baseline 3 applies.

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?

States a specific verb (Delete) and resource (SSL certificate) with the lookup key (by ID), which clearly separates it from npm_list_certificates, npm_get_certificate, npm_create_certificate and npm_renew_certificate. It does not, however, explicitly name or differentiate against those 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?

No guidance on when to use this versus alternatives such as renew_certificate, and no prerequisites or warnings. The agent must infer that this is the irreversible removal path from the verb alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state that the operation is irreversible, whether the host must be disabled first, what permissions are required, or what is returned/removed — all critical for a destructive tool with zero structured coverage.

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

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

One short, front-loaded sentence with zero filler, which is efficient. However, the extreme brevity comes at the cost of the behavioral warnings a destructive operation would need, so it is tight rather than well-rounded.

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, irreversible delete with no annotations and no output schema, the definition omits the safety context an agent needs: permanence of the action, preconditions, failure modes, and whether related configuration is removed. The schema covers the parameter, but the behavioral surface is essentially undocumented.

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

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

Schema description coverage is 100% and there is a single required parameter documented in the schema as 'The ID of the dead host to delete'. The description only restates 'by ID', adding no format, type, or sourcing guidance beyond the schema, so the baseline of 3 applies.

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 and resource ('Delete a dead host') plus the lookup key (by ID), which is unambiguous. It implicitly distinguishes itself from enable/disable/update dead-host siblings, but never names them or states the distinction.

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

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

There is no when-to-use guidance, no mention of prerequisites (e.g. the host must already be disabled or not in use), and no contrast with alternatives such as npm_disable_dead_host or npm_update_dead_host. The agent must infer the entire usage 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?

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about permanence, reversibility, cascade effects (e.g., attached certificates or dependent hosts), permission requirements, or whether confirmation is needed. 'Delete' conveys destructiveness only by connotation.

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 six-word sentence with the action and identifier front-loaded and zero filler. Nothing could be removed without losing 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 delete with full schema coverage and no output schema, the description is minimally sufficient to invoke the tool correctly. However, with zero annotation coverage, the irreversible/destructive nature and permission context an agent should know before calling a delete are absent.

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

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

Schema description coverage is 100% — host_id is fully documented in the schema as 'The ID of the proxy host to delete'. With a single well-described parameter, the baseline of 3 applies; the description's 'by ID' adds no syntax or format detail 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?

States a specific verb and resource ('Delete a proxy host') plus the key ('by ID'), which cleanly separates it from sibling mutations on other resources (npm_delete_dead_host, npm_delete_stream, npm_delete_certificate, etc.) and from the non-destructive get/update/enable/disable variants. It does not explicitly name an alternative tool, so it falls just short of a 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?

There is no when-to-use guidance beyond the obvious implication of the verb. Nothing states when deletion is appropriate versus disabling (npm_disable_proxy_host), nor any prerequisite such as ensuring the host is unused first. The agent must infer all of this from 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?

No annotations are provided, so the description carries the full burden. It says 'Delete' but discloses nothing about whether the operation is irreversible, what related resources (certificates, forwarding rules) are affected, or what authorization is required for a destructive mutation.

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?

One short sentence, front-loaded with the verb and resource, with no filler. It is efficient, though terse enough that it leaves room for necessary behavioral detail it never supplies.

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 an irreversible delete with no annotations and no output schema, the description omits the safety information an agent needs: confirmation expectations, side effects on dependent resources, and error cases for invalid IDs. The parameter is covered, but the destructive semantics are not.

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 coverage is 100% and the single parameter is fully documented in the schema as 'The ID of the redirection host to delete'. The description's 'by ID' adds nothing beyond it, so the baseline 3 applies.

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 ('Delete') and resource ('redirection host'), and the resource name alone separates it from the many sibling deletes (npm_delete_dead_host, npm_delete_proxy_host, npm_delete_stream, npm_delete_certificate). It does not explicitly reference siblings, but 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?

There is no guidance on when to delete versus when to disable (npm_disable_redirection_host) or update, and no prerequisites, permissions, or warnings about irreversibility are stated. The agent must infer everything about usage 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?

No annotations are provided, so the description carries the full burden. 'Delete' signals a destructive mutation, but the definition says nothing about irreversibility, required permissions, prerequisite state (e.g., disabled), or side effects on dependent hosts.

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 short sentence with zero filler and the action front-loaded. Brevity is appropriate for a one-parameter tool, though the terseness arguably reflects under-specification rather than disciplined editing.

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 definition omits everything an agent needs beyond the identifier: irreversibility, error conditions, and whether dependent resources are affected. The minimal schema doesn't compensate for these gaps.

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

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

Schema description coverage is 100%, and the single parameter is already documented as 'The ID of the stream to delete'. The description's 'by ID' adds nothing beyond the schema, so the baseline 3 for high coverage applies.

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?

States a specific verb (delete) and resource (stream), so the agent immediately knows the operation. However, it offers no differentiation from the many sibling delete tools (npm_delete_proxy_host, npm_delete_dead_host, npm_delete_access_list), relying entirely on the name to disambiguate.

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 when-to-use or when-not-to-use guidance at all. It doesn't say whether the stream must be disabled first, whether it must have no attached hosts, or what the alternative is when deletion isn't 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?

No annotations are supplied, so the description carries the full disclosure burden and delivers almost none of it: it does not say whether deletion is permanent/irreversible, whether it cascades (e.g., access lists, permissions), whether elevated permissions are required, or whether the user must be disabled first. 'Delete' is the only behavioral signal given.

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 four-word sentence with the destructive action front-loaded and zero filler. Nothing could be removed without losing meaning.

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 mutation with no annotations and no output schema, the description is too thin: an agent cannot tell whether the operation is reversible, what permissions it needs, or what happens to dependent resources. The schema covers the input exhaustively, but the behavioral context a deletion tool demands is absent.

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

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

Schema description coverage is 100% and the single user_id parameter is fully documented in the schema, so the schema does the heavy lifting. The description adds only 'by ID', which mirrors the schema rather than extending it, making the baseline of 3 appropriate.

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 and resource ('Delete a user'), which separates it from other delete siblings such as npm_delete_dead_host or npm_delete_certificate. It does not, however, distinguish itself from npm_delete_user-adjacent lifecycle tools or mention the inverse npm_create_user, so it sits just below the top band.

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 statement of when to use this tool versus alternatives, no prerequisites, and no note that the user must exist or be fetched via npm_get_user/npm_list_users first. The agent is left to infer usage entirely from the name.

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 behavioral burden, yet it only restates the operation. It does not say whether disabling is reversible, whether the host must already exist, whether the change is idempotent, or what happens to other configuration tied to the host.

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 tool is a single-action toggle and the description is one short front-loaded phrase with no filler. It is efficiently sized, though it could have used the same brevity to add one clause of necessary context.

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 toggle with no output schema, the description is minimally sufficient to invoke the tool correctly. However, with zero annotation coverage and no stated behavior for a state-changing operation, meaningful gaps remain.

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

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

Schema description coverage is 100% and the single host_id parameter is fully documented in the schema, so the baseline of 3 applies. The description adds no format, range, or lookup guidance beyond what the schema already supplies.

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 ('Disable') and resource ('dead host'), so an agent immediately knows the operation. It does not, however, distinguish itself from close siblings such as npm_enable_dead_host, npm_delete_dead_host, or npm_update_dead_host, leaving the boundary between disabling and deleting to inference.

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 like npm_delete_dead_host or npm_enable_dead_host. Usage is only weakly implied by the tool name, and no prerequisites or exclusion conditions 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 provided, the description carries the full burden of behavioral disclosure, and it says nothing about reversibility, required permissions, side effects on active traffic, or the response. Only the word 'Disable' hints at a mutation.

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 four-word phrase with no filler and the resource stated up front. It is efficient, though arguably too terse for a state-changing operation where extra context would be cheap to add.

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 toggle with no output schema, the definition is minimally viable. It still omits whether the change is reversible and what post-conditions to expect, which an agent would want before invoking a mutation.

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

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

Schema description coverage is 100% and the single parameter host_id is fully documented as 'The ID of the proxy host to disable', so the description adds nothing beyond the schema. Baseline 3 applies when the schema does the work.

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?

States a specific verb ('Disable') and resource ('proxy host'), which is enough to distinguish it from npm_enable_proxy_host and npm_delete_proxy_host at a glance. However, it offers no explicit contrast with those siblings, e.g. that disabling is a reversible state change rather than a deletion.

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 instead of npm_enable_proxy_host or npm_delete_proxy_host, nor any precondition (host must exist, must currently be enabled). Usage must be inferred entirely from the name.

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. 'Disable' implies a state mutation, but the description says nothing about whether the change is reversible (the sibling enable_redirection_host suggests it is), what permissions are required, or what effect disabling has on live traffic through the host.

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 single short phrase is front-loaded and free of padding, but it is under-specified rather than genuinely concise. There is no wasted language, yet the brevity reflects missing information rather than efficient writing.

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 tool with no annotations and no output schema, the description omits any information about return values, permissions, or side effects. An agent has no basis to know what happens after the call succeeds or fails.

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 is a single required parameter (host_id) with 100% schema description coverage, so the schema already explains it fully. The description adds no additional meaning about the parameter, making the baseline 3 appropriate.

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 clear verb and resource (disable a redirection host), so it is not misleading or vague. However, it is essentially the tool name restated verbatim and offers no differentiation from the many other disable_* siblings (proxy host, dead host, stream) that share the exact same shape.

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 when-to-use guidance, no mention of prerequisites, and no reference to alternatives such as npm_enable_redirection_host for reversing the action. The agent must infer everything from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about reversibility, idempotency, permission requirements, or what disabling actually does to traffic on the stream. For a state-changing mutation tool this is a significant omission.

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?

"Disable a stream" is front-loaded and free of waste, but at two words it is under-specified rather than genuinely concise. It earns its place but contributes almost no information beyond the tool name.

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?

Although the tool is simple (one required parameter) and has no output schema, the total absence of annotations and of any behavioral or usage context means an agent cannot confirm side effects or reversibility. The description is too thin for a mutation operation.

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

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

Schema description coverage is 100% and the single stream_id parameter is documented in the schema as "The ID of the stream to disable." The description adds no additional parameter meaning, so the baseline of 3 applies.

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 ("Disable") and resource ("a stream"), so the agent knows exactly what action is taken. It does not, however, distinguish this tool from its obvious siblings such as npm_enable_stream or the parallel disable operations on other resources, leaving gaps at the sibling level.

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 rather than npm_enable_stream, npm_delete_stream, or npm_update_stream, and no prerequisites are mentioned. The agent must infer usage purely from the name.

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 behavioral burden, and it conveys nothing beyond the name. For a mutation tool it omits whether the operation is reversible, what permissions are needed, whether it affects live traffic, or what side effects occur.

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 four-word sentence with zero padding and the action front-loaded. It is efficiently sized, though the brevity reflects under-specification rather than deliberate economy.

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, the description is too thin. An agent cannot tell what enabling means operationally, what happens on an already-enabled host, or what confirms success.

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 is only one parameter and schema description coverage is 100% ('The ID of the dead host to enable'), and the description adds no format, sourcing, or lookup guidance beyond that. Baseline 3 is appropriate when the schema already documents the parameter fully.

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?

States a specific verb ('Enable') and resource ('dead host'), and the resource noun distinguishes it from the many enable_* siblings for proxy hosts, streams, and redirection hosts. It does not, however, explicitly contrast itself with the adjacent npm_disable_dead_host or explain what state change occurs.

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 on when to use this versus npm_disable_dead_host, npm_update_dead_host, or the other enable tools. The enable/disable naming implies the usage, but nothing states prerequisites such as the host existing or being in a disabled state.

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 does not state side effects, idempotency, required permissions, reversibility, or what enabling a host actually changes. This is a mutation operation, and the description provides no transparency beyond the bare verb.

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 with no wasted words. However, its extreme brevity means it lacks the structural elements (scope, effect, conditions) that would make it genuinely useful for an agent.

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

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

For a mutation tool with no annotations and no output schema, the description is too sparse. It omits what enabling a host does, whether the host must exist or be disabled first, and what the operation returns, leaving important operational context unaddressed.

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 one parameter with 100% schema description coverage, and the schema already documents host_id as 'The ID of the proxy host to enable.' The description adds no additional parameter meaning, so the baseline of 3 is appropriate.

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 ('Enable') and resource ('proxy host'), which clearly distinguishes it from sibling operations like disable_proxy_host and enable_stream. However, it merely restates the tool name and adds no scope or effect beyond what the name already conveys, so it does not reach the explicit differentiation seen in top-scoring definitions.

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 indication of when to use this tool versus alternatives, no prerequisites, and no mention of related operations like disable_proxy_host or get_proxy_host. The description offers no usage context at all.

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 behavioral burden. It does not disclose whether the change takes effect immediately, whether it is reversible, what permissions are needed, or what happens to traffic to the host on enable. For a state-mutating tool with zero annotation coverage this is a real 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 single sentence is front-loaded and free of filler, but its extreme brevity stems from under-specification rather than tight editing.

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 required param, no output schema, no nesting), so little is strictly required. However, as a mutation with no annotations the description should at least state the effect of enabling, which it omits.

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

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

Schema description coverage is 100% with a single host_id parameter that is fully documented in the schema. The description adds no format, type, or sourcing detail beyond it, so the baseline 3 applies.

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 (Enable) and resource (redirection host), which distinguishes it from the sibling npm_disable_redirection_host. It is clear, though it does no explicit sibling routing beyond the obvious enable/disable contrast.

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 enable a redirection host, no prerequisites (e.g., does the host need to exist in a disabled state?), and no mention of alternatives. The agent is left to infer usage entirely.

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 supplied, so the description carries the full behavioral burden, yet it discloses nothing about the state change, idempotency, required permissions, or whether the action is reversible. "Enable" weakly implies a state toggle, but that is the only signal.

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?

It is a single front-loaded phrase with zero waste, which is structurally clean. It is only penalized indirectly for being under-specified rather than verbose.

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

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

For a mutation tool with no annotations and no output schema, the definition should at least state what enabling does to the stream, its prerequisites, and its reversibility. With only the bare phrase, an agent has no basis 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 coverage is 100% and the single stream_id parameter already has a descriptive schema entry. The description adds no format, range, or sourcing guidance beyond what the schema provides, so the baseline 3 applies.

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?

"Enable a stream" names a verb and resource, but it essentially restates the tool name npm_enable_stream and offers no detail about what enabling means or how it differs from siblings like npm_disable_stream or npm_get_stream. It is minimally clear rather than genuinely informative.

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 when-to-use guidance, no note about when a stream must be enabled vs. left disabled, and no mention of the obvious counterpart npm_disable_stream. The agent must infer everything from the name.

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 behavioral burden, yet it discloses nothing beyond the obvious read implication of 'Get'. It says nothing about permissions required, behavior for an unknown ID, or whether the response is cached/scoped.

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 front-loaded sentence with zero filler, correctly sized for a simple lookup tool. It is efficient but borders on under-specified rather than deliberately minimal.

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 trivial two-parameter read tool with full schema coverage and no output schema, the definition is minimally adequate. However, the absence of annotations means auth/error behavior remains undocumented, leaving a gap an agent could hit at call time.

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

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

Schema description coverage is 100%, so both list_id and the optional expand parameter are already documented in the schema; baseline 3 applies. The description's 'by ID' merely echoes the required parameter and adds no syntax or format detail.

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?

States a specific verb (Get) plus resource (access list) and scope (by ID), which reads clearly against siblings like npm_list_access_lists and npm_update_access_list. It stops short of explicitly naming the sibling it complements or noting it returns a single record, so it is clear but not fully differentiated.

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

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

The phrase 'by ID' implies the prerequisite that an ID must already be known, but there is no explicit when-to-use guidance, no mention of npm_list_access_lists as the way to discover IDs, and no exclusions or error 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?

No annotations are provided, so the description must carry the behavioral burden. 'Get details' makes the non-destructive read nature apparent, but it says nothing about permission requirements, behavior for an unknown/invalid certificate_id, or error responses.

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, front-loaded sentence with no filler. It is appropriately sized, though the brevity is a byproduct of omitting useful detail rather than careful editing.

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 single-resource read with 100% schema coverage and no output schema, the core information is present. However, with no annotations, the description leaves the safety/auth profile and failure behavior entirely unstated, so it is only minimally 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?

Schema description coverage is 100%: both certificate_id and expand are documented in the schema. The description only restates that lookup is by ID and adds no syntax, format, or semantics for the expand parameter, so the baseline 3 applies.

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?

States a specific verb ('Get details') and resource ('SSL certificate') scoped by ID, so the agent knows exactly what is returned. It does not explicitly distinguish itself from npm_list_certificates, but the 'by ID'/'specific' framing makes the singular-vs-list distinction reasonably evident.

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 explicit when-to-use statement and no sibling is named. The only guidance is implicit in 'specific ... by ID', which weakly suggests use over a list call when the identifier is known; nothing addresses when this is not the right 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, the description carries the full behavioral burden, yet it only says it retrieves details. It does not disclose behavior on a missing/invalid ID (error vs empty), whether the call is read-only and safe, or any permission requirements. For a 2-param tool with zero annotation coverage this is thin.

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 front-loaded sentence of nine words with no filler or repetition. It is efficient, though it is so terse that it omits any behavioral context an agent would need.

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

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

For a simple read tool with a fully documented schema and no output schema, the description is minimally adequate: the what is clear, but how it behaves on failure and what the 'expand' parameter buys are left unexplained. It covers the basics without the extra context a zero-annotation tool could benefit from.

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

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

Schema description coverage is 100% (host_id documented as the dead host ID, expand as comma-separated objects), so the schema already carries parameter meaning. The description adds nothing beyond the schema, which is the expected baseline 3 when the schema does the heavy lifting.

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

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

States a specific verb (Get) and resource (dead host) with the lookup key (by ID), so an agent knows exactly what it retrieves. It does not, however, differentiate itself from sibling readers like npm_list_dead_hosts or the other npm_get_* tools beyond the resource noun.

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 explicit guidance on when to use this tool versus npm_list_dead_hosts (to enumerate) or npm_update_dead_host (to modify). Usage is only implied by the word 'Get' and the 'by ID' lookup, with no conditions, exclusions, or named 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. It implies a non-destructive read but says nothing about required permissions, error behavior for an unknown host_id, or what the returned 'details' comprise.

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 front-loaded sentence with no filler; the retrieval key is placed at the end where it reads naturally. It is efficient, though 'details' is a vague noun for a resource whose return shape is undocumented.

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 output schema, the description should clarify what the 'details' payload contains and what expand yields, but it does neither. For a simple read this is not catastrophic, yet the expand parameter's effect remains unexplained anywhere.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema and the baseline is 3. The phrase 'by ID' merely restates host_id and the description adds nothing about the expand parameter (which related objects are valid) 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 names a specific verb (get), resource (proxy host), and retrieval key (by ID), which is clearly distinguishable from the sibling npm_list_proxy_hosts. It stops short of explicitly naming that sibling or the mutation siblings (npm_update_proxy_host, npm_delete_proxy_host), so differentiation is implied by the name rather than stated.

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 when-to-use guidance at all: nothing tells the agent to call npm_list_proxy_hosts first to discover a host_id, nor when this is preferable to listing. Usage is only inferable from the tool name.

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 behavioral burden. 'Get' implies a read, but the description says nothing about required permissions/API key, behavior on an unknown or deleted host_id, or what the returned 'details' comprise.

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 short sentence with zero filler, front-loaded with the verb and resource. It is efficient, though almost too terse to earn the top mark.

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 single-record getter with no output schema, the description is minimally sufficient but leaves the shape of the returned 'details' undefined. An agent can call it, but cannot predict the response payload.

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

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

Schema description coverage is 100%, so both host_id and expand are already documented in the schema. The description adds no meaning beyond that baseline, not even acknowledging the existence of the expand parameter.

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?

States a specific verb (Get) and resource (redirection host), and the phrase 'a specific ... by ID' distinguishes it from the sibling npm_list_redirection_hosts. It doesn't explicitly name the list tool as an alternative, so it falls just short of 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?

Usage is only implied: 'by ID' signals this is the single-record lookup versus the list sibling, but there is no explicit when-to-use guidance, no mention of what to do if the ID is unknown, and no routing to alternatives such as npm_list_redirection_hosts.

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. A "report" implies a non-mutating read, and the zero-parameter schema reinforces that, so the safety profile is inferable. However, nothing is said about caching, freshness, whether counts span all host types, or cost of the call.

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 compact phrase with the resource and its scope front-loaded; the parenthetical enumeration is efficient. It is minimal but nothing is wasted, though it is arguably terse enough to be under-specified.

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 output schema and no annotations, the description should ideally describe the return shape (e.g., a counts object with one field per host type). It names the categories but does not confirm whether the response is counts keyed by those categories, leaving the agent to infer the structure.

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, so per the rubric this is the baseline 4. The description correctly adds no parameter detail because there is nothing to parameterize.

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 gives a specific verb ("Get") and resource ("host count report") and enumerates the four categories counted: proxy, redirection, stream, dead. This distinguishes it from the many list/get single-host siblings, which return entities rather than aggregate counts. It is clear but does not frame the distinction explicitly.

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 report versus the list_* tools (e.g., to obtain totals without fetching every host). The intended use as a summary/overview tool is only implied by the word "report". 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?

No annotations are provided, so the description carries the full behavioral burden. "Get" implies a read, but nothing is said about behavior when the setting_id does not exist, required permissions, or the shape of the return value. For a tool with zero annotation coverage 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?

One short, front-loaded sentence with no filler; the verb and the lookup key come first. It is efficient, though its extreme brevity borders on under-specification rather than tight writing.

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 simple one-parameter read tool with no output schema, so the bar is low, but the description still omits error behavior for missing IDs and any hint of the returned setting shape. Adequate but with clear residual gaps.

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

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

Schema coverage is 100% and the single parameter is fully documented in the schema (including an example value "default-site"). The description's "by ID" adds no meaning beyond the schema, so the baseline 3 applies.

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 and resource ("Get a specific setting") plus the lookup key ("by ID"), so the agent knows exactly what the tool retrieves. It does not, however, differentiate itself from siblings like npm_list_settings or npm_update_setting, which an agent could easily confuse for the same 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?

There is no guidance on when to use this instead of npm_list_settings (retrieve all) or npm_update_setting. The single-item-by-ID framing implicitly suggests it is for known IDs, but no conditions, prerequisites, or alternatives are stated explicitly.

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 supplied, so the description carries the full burden. The verb 'Get' does convey a non-mutating read, which is the main behavioral fact here, but nothing is said about permissions, error behavior for unknown IDs, or rate limits.

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 front-loaded sentence with no filler; every word (verb, resource, key) earns its place.

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

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

For a simple two-parameter read tool with a fully described schema and no output schema, the description is minimally adequate but leaves the expand parameter's effect and any failure modes unexplained.

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 coverage is 100%, so both stream_id and expand are already documented in the schema. The description's 'by ID' only restates what the schema says and adds nothing about the expand parameter, so the baseline 3 applies.

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?

States a specific verb (Get) and resource (stream) with the keying dimension (by ID), so the agent can distinguish it from the many mutating siblings like npm_update_stream and npm_delete_stream. It does not, however, explicitly contrast itself with npm_list_streams or any other read tool.

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

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

The description gives no when-to-use guidance and names no alternatives. An agent must infer from the name alone that this is the single-record counterpart to npm_list_streams.

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, yet it says nothing about auth requirements, rate limits, error behavior for an unknown ID, or what fields come back. 'Get' implies a safe read but nothing confirms 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?

A single tight sentence with no padding, and the verb-resource pairing is front-loaded. It is appropriately sized for a simple lookup, though it is almost terse for a tool with no annotations.

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

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

For a simple read tool with a fully documented schema, the definition is minimally viable. However, with no annotations and no output schema, the description leaves the return shape and safety profile entirely to inference.

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

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

Schema description coverage is 100%, so the schema already documents both user_id and expand. The description's note that "me" addresses the current user restates the schema's own const constraint rather than adding new meaning, so baseline 3 is correct.

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?

States a specific verb (get) and resource (user by ID) with the scope of a single record, which implicitly distinguishes it from npm_list_users. It does not explicitly name a sibling, so it falls short of a 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?

Usage is only implied: the agent can infer 'use this to fetch one user's details' but the description never states when to prefer it over npm_list_users or npm_get_user_permissions, nor any prerequisite. No exclusions or alternatives are given.

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. 'Get' implies a read, but nothing is said about what the permissions object contains, whether it reflects inherited/effective permissions, or the auth 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?

A single short sentence with no waste, front-loaded with the core action. It is terse rather than padded, though it borders on under-specification.

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 tool with full schema coverage the description is minimally adequate; no output schema exists, so it need not explain return values. However, with no annotations it omits the permissions model and auth context an agent would want.

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

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

Schema description coverage is 100%, so user_id is already documented as 'The ID of the user'. The description adds only the scoping phrase 'for a specific user' and no format or sourcing detail beyond the schema. Baseline 3 is appropriate.

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?

States a specific verb (get) and resource (permissions) scoped to a user, so it is distinguishable from npm_get_user (user details) and npm_list_users. It does not explicitly name those siblings, but the resource noun alone conveys the purpose clearly.

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 on when to use this versus npm_get_user or npm_list_users, and no prerequisites stated. The agent must infer that this is the permissions-only read from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read-only enumeration but says nothing about result size, pagination, whether the list is tenant-scoped, or what fields each entry contains. For a list endpoint with zero annotation coverage 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?

A single front-loaded phrase with no filler, which is appropriate for a simple list tool. It is on the terse side and does not use the remaining space to say anything an agent would want, but nothing is wasted.

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-optional-parameter list tool with no output schema, the description is minimally adequate: an agent can identify and invoke it. However, it omits return-shape expectations and any hint about the volume or default ordering of results, which leaves the definition thin even for a simple endpoint.

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

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

Schema description coverage is 100%, so both 'query' and 'expand' are already documented in the schema. The description adds nothing about what keyword filtering means or which related objects can be expanded, so the baseline 3 applies — no value added, but none 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 names a specific verb ('List') and resource ('access lists') and clarifies scope with parenthetical examples ('basic auth, IP restrictions'). That said, it does not explicitly distinguish itself from sibling npm_get_access_list, which retrieves a single list, so an agent must infer the collection-vs-single distinction from the name alone.

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 statement of when to use this tool versus alternatives such as npm_get_access_list or npm_list_settings. No prerequisites or context for the listing operation are given. Usage must be inferred entirely from the tool name and sibling naming conventions.

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 discloses nothing beyond the bare action. It doesn't state that the operation is read-only, whether it needs admin permissions, how far back 'recent' reaches, or whether results are paginated or ordered.

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 short, front-loaded sentence with no filler. However, the brevity edges into under-specification rather than disciplined conciseness, since 'recent' is left undefined.

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?

No output schema exists, so the description must stand in for return-value information, and it doesn't — the size, ordering, and time window of the returned entries are all unstated. For a windowed listing tool this leaves a real 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 takes zero parameters, so the schema cannot be short of anything and the baseline is 4. The description neither adds nor needs parameter detail.

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?

States a specific verb (list) and resource (audit log entries), and 'recent' hints at the scope. No other audit-log sibling exists, so there is nothing to disambiguate against, but the purpose is unambiguous and agent-legible.

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 when-to-use guidance, no alternatives, and no explanation of what 'recent' means in practice. An agent knows what it does but has no signal about when it should reach for this versus general settings/report 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 behavioral burden. 'List all' weakly implies a read-only operation, but it discloses nothing about permissions, pagination, result size, or whether filtering/sorting is supported.

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 front-loaded sentence with zero waste. It is appropriately sized, though arguably under-specified rather than optimally concise given the missing behavioral context.

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-optional-parameter list tool with no output schema and no annotations, the description is the minimum viable. It omits return-shape and filtering context that would help an agent call it correctly, but nothing critical is contradicting.

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

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

Schema description coverage is 100%, documenting both 'query' and 'expand' fully, so the schema does the heavy lifting. The description adds no additional meaning about parameter behavior, which is the correct baseline of 3.

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 (List) and resource (SSL certificates) scoped to Nginx Proxy Manager, making the purpose immediately clear. It lacks explicit differentiation from the singular sibling npm_get_certificate, but the plural 'all' implies a collection listing.

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

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

There is no guidance on when to use this versus npm_get_certificate or other list tools, no mention of prerequisites, and no exclusions. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full disclosure burden. It implies a read-only, unpaginated enumeration via 'List all', but says nothing about whether disabled hosts are included, ordering, pagination limits, or whether auth/scope is required.

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 front-loaded sentence with zero filler; the resource and scope are stated immediately with no redundant restatement of the name.

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, no-required-parameter list tool with full schema coverage and no output schema, the description is minimally sufficient. However, with no annotations at all it leaves the read-only/safety profile and the shape of the returned host list entirely unstated.

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

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

Schema description coverage is 100% and both parameters (query, expand) are documented in the schema, so the baseline of 3 applies. The description adds no syntax or format detail about filtering or expansion beyond what the schema already states.

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?

States a specific verb (List) plus resource (404 dead hosts in Nginx Proxy Manager), which cleanly separates it from the get/create/update/delete/enable/disable dead-host siblings and from other npm_list_* tools. An agent can select it without opening the schema.

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 when-to-use guidance, no mention of prerequisites or alternatives (e.g. npm_get_dead_host for a single host). The only implied usage is 'I want the whole collection', which the agent must infer from the verb 'List'.

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

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

No annotations are provided, so the description carries the full burden. 'List supported' implies a read-only, paginated-free enumeration of a static set, which is useful, but nothing is said about the response shape, whether the list is static or dynamic, or what identifier format is returned for use in a DNS challenge configuration.

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 front-loaded phrase with no filler, hedging, or redundancy. Every word (list, supported, DNS providers, DNS challenge certificates) carries meaning.

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?

There is no output schema and no annotations, so the description is the only source of truth, yet it does not explain what the returned values are or how they should be used in a certificate DNS challenge setup. For a zero-parameter tool this is minimally adequate but leaves the return contract implicit.

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, so there is no parameter semantics to document and the baseline of 4 applies. The description correctly avoids inventing any input behavior.

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 gives a specific verb (List) and resource (supported DNS providers) plus a scope qualifier (for DNS challenge certificates), which is enough to distinguish it from generic siblings like npm_list_settings. However, it does not name or contrast with any related sibling such as npm_create_certificate or npm_list_certificates where the provider list would be consumed.

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 explicit when-to-use statement, no prerequisite, and no mention of alternatives. An agent can infer it is relevant when configuring DNS challenge certificates, but the description never states that linkage or any condition under which it should be called instead of 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 of behavioral disclosure. "List" implies a read-only operation, but nothing is said about pagination, result limits, authentication requirements, or what "all" means at scale. For a tool with zero annotation coverage this is a significant gap.

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

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

A single short sentence with the verb and resource front-loaded and zero wasted words. Appropriate for a trivial list 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 read-only list operation the description is minimally sufficient, but with no output schema the agent gets no hint about the shape or size of the returned host list, and there is no annotation coverage of safety or pagination. Adequate, with clear gaps.

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

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

Schema description coverage is 100%, so both the query and expand parameters are already fully documented in the schema; the baseline of 3 applies. The description adds no meaning about filtering or expansion beyond what the schema states.

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?

States a specific verb ("List") and resource ("proxy hosts") with a scope qualifier ("all ... configured"), so the agent can tell it apart from sibling reads like npm_list_redirection_hosts or npm_list_streams by resource alone. It never explicitly names an alternative or contrast target, 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?

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives (e.g. npm_get_proxy_host for a single host). The agent must infer usage purely from the name.

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. 'List' implies a non-destructive read, but nothing is said about pagination, result volume, or whether filtering changes the response shape. For a tool with zero annotation coverage this is a thin disclosure.

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 front-loaded sentence with no filler. Every word contributes to identifying the resource being listed.

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 (two optional, fully documented params, no output schema), so little context is strictly required. However, with no annotations and no output schema, the description leaves the response shape and the effect of the query/expand params unaddressed.

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

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

Schema description coverage is 100%, so the schema already documents both optional parameters (query, expand) adequately. The description adds no semantics beyond the schema, so the baseline 3 applies.

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?

States a specific verb (list) and resource (redirection hosts in Nginx Proxy Manager), which is clearly distinct from sibling resources such as proxy hosts, dead hosts, and streams. It stops short of naming the counterpart that the agent should choose instead, but the resource noun alone differentiates it from 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?

There is no guidance on when to use this versus alternatives such as npm_list_proxy_hosts or npm_get_redirection_host, nor any mention of prerequisites. The agent must infer usage entirely from the tool name.

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. "List all" does imply a safe, non-mutating bulk read and communicates scope (all settings, not one), which is genuine context. It still says nothing about authentication requirements, whether sensitive values are masked, or the shape of the returned collection.

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 front-loaded sentence with no filler. It is impossible to trim without losing the one piece of information it carries.

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 with no output schema, the main open questions are what the settings collection contains and whether values are redacted. The description answers neither, and only the word "all" scopes the result. Adequate as a minimum viable entry, but not self-sufficient.

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, so there is no parameter semantics for the description to add. Baseline 4 applies; nothing is missing 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?

States a specific verb (List) and resource (Nginx Proxy Manager settings), so the agent knows exactly what comes back. It does not, however, distinguish itself from the sibling npm_get_setting, which reads a single setting rather than the full collection.

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 when-to-use guidance and no routing to alternatives. With npm_get_setting and npm_update_setting present as siblings, the description should say this is the bulk-retrieval variant and that get_setting is for a single key, but it offers nothing.

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 behavioral burden. It implies a read-only listing, but discloses nothing about pagination, result limits, ordering, whether the list is scoped to the authenticated user, or what happens on an empty result set.

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, front-loaded sentence with zero filler. Every word earns its place and the key resource type is stated immediately.

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

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

For a simple read-only list tool with a fully documented 2-parameter schema and no output schema, the description is minimally sufficient. It would be stronger with a note on result volume/pagination or a pointer to the singular get tool, but nothing critical to correct invocation 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 100%, so both 'query' and 'expand' are already documented in the schema. The description adds no syntax, format, or semantics beyond what the schema states, which matches the baseline 3 when the schema does the heavy lifting.

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

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

States a specific verb ('List all') and a precise resource ('TCP/UDP stream proxies configured in Nginx Proxy Manager'). This implicitly distinguishes it from sibling list tools that return other host types (npm_list_proxy_hosts, npm_list_redirection_hosts, npm_list_dead_hosts), though it never names them or points to the singular npm_get_stream counterpart.

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 when-to-use guidance, no mention of when to prefer npm_get_stream over listing, and no indication of how 'query' or 'expand' should be used to narrow results. The agent must infer everything about invocation 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond read semantics implied by 'List'. It says nothing about required admin permissions, pagination, result caps, or return shape for a user-enumeration tool that is typically sensitive.

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 front-loaded sentence with no filler; the resource and action are the first words the agent reads. Nothing to trim.

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 output schema and no annotations, the description is the only prose context, and it is adequate but thin for a list endpoint. The parameters are covered by the schema, but permission and pagination expectations are absent.

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

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

Schema description coverage is 100%, so both 'query' and 'expand' are already documented in the schema, making 3 the baseline. The description adds no syntax or usage detail for these parameters — and 'List all' slightly understates the existence of filtering.

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?

States a specific verb ('List') and resource ('Nginx Proxy Manager users'), clearly separating it from npm_get_user and npm_create_user by scope. It does not explicitly name a sibling or contrast usage, so it stops short of a 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?

There is no when-to-use guidance, no mention of prerequisites, and no routing away from alternatives such as npm_get_user (single record) or npm_get_user_permissions. The only signal is the verb 'List', which the agent must interpret unaided.

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, and it says nothing about whether renewal requires ACME/HTTP challenge completion, whether it replaces the existing certificate in place, whether the operation is asynchronous, or what permissions are needed. This is a meaningful gap 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?

One short sentence that front-loads the action and resource with zero filler or redundancy. Nothing could be removed without losing 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 renewal tool with a fully documented schema, the definition is minimally viable, but with no annotations and no output schema it omits what happens on success or failure and any prerequisites. It is adequate rather than 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?

Schema description coverage is 100%, and the single certificate_id parameter is fully documented in the schema. The description adds no extra meaning (such as where to obtain the ID or whether it accepts a domain name instead), so the baseline 3 applies.

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 (renew) and a specific resource (a Let's Encrypt SSL certificate), so the agent can tell it apart from npm_create_certificate or npm_delete_certificate. It stops short of explicitly naming sibling tools or clarifying how renewal differs from creation.

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 renew versus create a certificate, what prerequisites exist (e.g., the certificate must be near expiry or the domain must be validated), or what to do if renewal fails. The agent must infer usage entirely from the tool name.

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 and discloses almost nothing. All 8 permission parameters are required, which strongly implies the call replaces the user's entire permission set rather than patching individual fields — a critical, unreversible-sounding behavior that goes unstated, as do auth requirements and what happens to omitted areas.

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 front-loaded sentence with no filler or repetition; every word earns its place. It is arguably undersized for an 8-required-parameter mutation, but the terseness itself is not wasteful.

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 an 8-required-param mutation with no annotations and no output schema, the description is far too thin: it omits replacement semantics, permission/auth requirements, and any guidance on reading current permissions first. The agent has the field-level schema but nothing about the operational contract.

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

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

Schema description coverage is 100% and every parameter carries a description plus an enum (hidden/view/manage) or scope enum, so the schema does the heavy lifting. The description adds no meaning beyond the schema — notably it never explains that all eight are mandatory and mutually coupled.

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?

States a specific verb ('Set') and resource ('permissions for a specific user'), so the agent knows this is the write counterpart to the permission model. It does not, however, differentiate itself from the sibling npm_get_user_permissions or npm_update_user, leaving the agent to infer which one mutates.

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 when-to-use guidance, no prerequisites, and no mention of the sibling npm_get_user_permissions that would be the natural companion for reading current state before writing. The agent gets no signal about when this tool is the right choice.

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 implies a non-destructive connectivity probe but never confirms that it makes no state changes, doesn't state whether it requires network access from the server, how long it waits, or what a failure looks like. Only the bare purpose is disclosed.

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 front-loaded sentence with no filler or redundancy. It is appropriately sized, though it is short enough that it could have absorbed one more clause of guidance at no cost to 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?

For a validation/test tool with no annotations and no output schema, the description should at minimum explain what the result reports (per-domain reachability? errors?) and any prerequisites. None of that is present, so an agent cannot predict the outcome of calling 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?

There is a single parameter with 100% schema description coverage ('List of domains to test'), so the schema already documents it fully. The description adds only the ACME/HTTP-01 framing, no format, validation, or limit details, so the baseline 3 for high schema coverage applies.

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?

States a specific verb (test) and resource (domain reachability for the HTTP-01 ACME challenge), which is enough to distinguish it from the CRUD siblings like npm_create_certificate or npm_get_certificate. It never explicitly names a sibling or states its relationship to certificate issuance, so it falls short of a 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?

There is no guidance on when to run this test — e.g. before calling npm_create_certificate with an HTTP-01 challenge, or when diagnosing a failed issuance. No prerequisites, no exclusions, no alternatives are mentioned; the agent must infer the usage context entirely.

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 entire behavioral burden, and it discloses nothing beyond the bare verb. It does not say whether omitted fields are preserved or cleared, whether items/clients replace or append to the existing list, whether password data is rewritten on every call, or what auth/permissions are required. For a destructive mutation of a security control (IP allow/deny plus Basic Auth credentials) this is a serious 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?

A single front-loaded sentence with zero waste; nothing is padded or redundant. It is however terse to the point of underspecification for a six-parameter mutation tool, which caps this rather than lifting it to 5.

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 six parameters, no annotations, no output schema, and nested credential/IP structures, a one-line description leaves the agent without the semantics it needs to update an access list safely. The schema supplies field names but the description should explain replacement vs merge behavior and the security implications.

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

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

Schema description coverage is 100%, so list_id, name, items, clients, pass_auth, and satisfy_any are all documented in the schema itself. The description adds no format or interaction semantics (e.g. how clients directives combine with satisfy_any) beyond that, so the baseline 3 applies.

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?

States a specific verb (Update) and resource (an existing access list), which cleanly separates it from the create/delete/list siblings. It stops short of describing what aspects of the access list are updatable or how this differs from npm_update_stream or npm_update_user, but the core purpose 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 when-to-use guidance, no prerequisites (e.g. the list must already exist), and no mention of alternatives such as npm_create_access_list for new lists. The word 'existing' is the only hint about context, and it is left for the agent to infer.

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 behavioral burden. It notes that advanced_config is supported, but says nothing about whether unspecified fields are preserved (PATCH vs PUT semantics), permission/auth requirements, reversibility, or side effects on SSL/HSTS settings — significant gaps for a mutation 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 short, front-loaded sentences with no filler. The core operation leads, with the advanced_config note as secondary. Efficient, though the second sentence adds little beyond the schema.

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 an 8-parameter mutation tool with no annotations and no output schema, the description is too thin. It omits update semantics (partial vs full), permission requirements, and what happens to the certificate/SSL fields when changed — the exact behavioral context an agent needs before invoking.

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

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

Schema description coverage is 100%, so all eight parameters (host_id, ssl_forced, domain_names, hsts_enabled, http2_support, certificate_id, advanced_config, hsts_subdomains) are already documented in the schema. The description only calls out advanced_config, which is redundant with the schema, so baseline 3 applies.

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 clear verb+resource ('Update an existing dead host'), which is unambiguous on its own. However, it offers no differentiation from the many sibling update tools (npm_update_proxy_host, npm_update_redirection_host, npm_update_stream, npm_update_access_list), so an agent must infer the target type from the tool name alone.

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 versus alternatives, no prerequisites (e.g. the host must already exist, or that this is a partial vs full update), and no mention of related enable/disable/delete siblings. The single sentence merely restates the operation.

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 and does not meet it. It never says whether this is a partial (PATCH-style) or full-replace update, whether previously set fields omitted from the call are cleared, whether changes require a restart or take effect immediately, or what permissions are needed — all critical for an 18-parameter mutation.

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 the core action front-loaded and no filler. The second sentence repeats 'advanced_config' twice in close succession, so it is slightly less tight than it could be, but it is well within an appropriate size.

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 an 18-parameter mutation tool with no annotations and no output schema, the description leaves the important things unsaid: update semantics, reversibility, side effects on dependent hosts, and required permissions. The fully documented schema covers the parameter surface, but the behavioral surface is largely unaddressed.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does add a small amount of meaning by calling out advanced_config as raw custom nginx configuration and noting that locations carry per-location advanced_config, but the other 16 parameters get no added interpretation.

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?

States a specific verb and resource ('Update an existing proxy host') and names two capabilities it supports. It is clearly distinguishable from npm_create_proxy_host / npm_get_proxy_host / npm_delete_proxy_host by name, but the description never references any sibling or scoping condition to make the boundary 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?

There is no guidance on when to call this versus npm_enable_proxy_host, npm_disable_proxy_host, or npm_create_proxy_host, and no stated prerequisites (e.g. that host_id must reference an existing host obtained from npm_get_proxy_host). Usage is only implied by the word 'update'.

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 behavioral burden. It states that it updates a host and supports advanced_config, but does not disclose whether updates are partial or full, what permissions are required, whether changes are reversible, or the risks of custom nginx configuration.

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, with the core purpose front-loaded and no obvious filler. The second sentence about advanced_config is somewhat redundant with the schema but still 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?

This is a mutation tool with 13 parameters, no annotations, and no output schema, yet the description omits critical context such as partial update semantics, permission requirements, and side effects or risks of advanced_config. It provides only the bare minimum purpose statement for a complex update operation.

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

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

Schema description coverage is 100%, so the schema already documents all 13 parameters. The description only repeats that advanced_config is supported, adding no syntax, format, or constraint details beyond what the schema provides, which matches the baseline of 3 for high-coverage schemas.

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 gives a clear verb and resource ('Update an existing redirection host'), distinguishing it from create, delete, list, and get operations. It does not explicitly differentiate itself from sibling update tools for other host types, but the resource name itself provides adequate separation.

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 explicit guidance on when to use this tool versus alternatives, nor any mention of prerequisites such as needing an existing host ID or admin permissions. The phrase 'Update an existing redirection host' implies the usage context but leaves all routing decisions 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?

No annotations are provided, so the description carries the full behavioral burden, and it does not disclose whether the update requires specific permissions, whether it is reversible, or what happens to unset fields. The conditional requirements (html needed when value='html', redirect needed when value='redirect') live only in the schema, leaving the description thin for a mutation 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 short sentence with no waste and the core action front-loaded. It is efficient, though the brevity borders on under-specification rather than true 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?

For a mutation tool with no annotations and no output schema, the description is too thin: it omits what settings exist, whether changes are reversible, and any error or permission context. The schema covers parameters well, but the behavioral side is almost entirely absent.

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

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

Schema description coverage is 100%, so setting_id, value, html, and redirect are already documented, including the enum and conditional requirements. The description adds only a loose hint about setting scope, so the baseline of 3 applies.

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?

States a clear verb+resource ('Update a setting'), and the parenthetical '(e.g., default site behavior)' hints at scope. However, it is vague about what a 'setting' actually is or which settings exist, so an agent can't fully distinguish the target from get_setting/list_settings beyond the obvious verb difference.

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 when-to-use guidance, no prerequisites, and no mention of alternatives (e.g., npm_get_setting to read first, or npm_list_settings). The agent must infer that this is the mutation counterpart to get_setting purely from the verb.

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 entire behavioral burden, and it discloses nothing. It does not state that this is a mutation, whether it is a full replace or a partial patch, what happens to fields left unspecified, whether changes are reversible, or what permissions are required.

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 single five-word sentence is short but not concise in any useful sense — it is under-specified rather than tight. Nothing is front-loaded because nothing of substance 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 an eight-parameter mutation tool with no annotations and no output schema, the description is far too thin. Although the input schema documents the parameters, the agent still lacks mutation semantics and any indication of what the update returns or affects.

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

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

Schema description coverage is 100%, with all eight parameters individually documented, so the schema already carries parameter meaning and the baseline of 3 applies. The description adds no additional semantics such as which fields are optional or how certificate_id="new" behaves.

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 phrase "Update an existing stream" does little more than restate the tool name npm_update_stream. It identifies a verb and a resource, but gives no sense of scope (what settings are updatable) and no differentiation from siblings like npm_create_stream, npm_get_stream, or npm_enable_stream.

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 when-to-use guidance, no statement of prerequisites (e.g. an existing stream_id is required), and no mention of the alternative tools an agent should consider first. The description offers nothing to route between npm_update_stream and its siblings.

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

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

With no annotations, the description carries the full behavioral burden, yet says nothing about how the update behaves: whether it is a partial/patch update, whether omitted fields are preserved or cleared, whether it is idempotent, or what permissions the caller needs. 'Update' is the only signal, and it is the same signal the name already gives.

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?

One short, front-loaded sentence with no filler, but it is under-specified rather than genuinely concise — four words cannot cover a six-parameter mutation tool. Size is efficient but the content budget is unspent.

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 mutation tool with six parameters, no annotations, and no output schema, the description omits critical context: partial-update semantics, permission requirements, and the effect of is_disabled or roles changes. The agent has enough to attempt a call but not enough to call it correctly with confidence.

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

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

Schema description coverage is 100%, so all six parameters (user_id, name, email, roles, nickname, is_disabled) are already documented in the schema. The description adds no syntax, format, or constraint detail beyond that, so the baseline of 3 applies.

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?

States a clear verb+resource (update a user) with a scope qualifier ('existing'), which implicitly separates it from npm_create_user and npm_delete_user. It does not, however, differentiate itself from the overlapping sibling npm_set_user_permissions, nor indicate which user attributes are mutable.

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 on when to use this versus npm_create_user, npm_delete_user, npm_set_user_permissions, or npm_get_user, and no prerequisites (e.g., needing the user_id from npm_list_users). The agent must infer the routing entirely from the tool name.

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