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

No annotations are provided, so the description must carry the burden. It discloses only that API 3.x tokens are scoped, but omits critical behaviors: whether the token secret is returned only once, whether existing tokens are affected, and any permission requirements.

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

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

A single 9-word sentence that puts the verb and object first. No redundant or filler content; it is appropriately short.

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 or annotations, the description is too sparse for a create operation. It fails to mention what the response contains (e.g., the token value), how to discover valid scopes, or any post-creation consequences, which are important for an API token creation tool.

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

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

The input schema fully describes all three parameters (name, scopes, expiresInDays) with its own descriptions, so the description adds no additional parameter semantics. The 'omit for full access' behavior is documented in the schema, not the description.

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 API token'. Among the api_tokens_* siblings, only this one creates tokens, so no ambiguity; the parenthetical about API 3.x scoping adds useful context.

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

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

No explicit guidance on when to use this vs alternatives like api_tokens_list or api_tokens_delete. The name implies creation, but there is no statement about prerequisites (e.g., needing to list scopes first) or exclusion cases.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Delete' indicates a destructive mutation, but there is no mention of whether deletion is irreversible, what happens if the token does not exist, whether authorization is required, or what response is returned. This is a meaningful gap for a tool that permanently removes a resource.

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, directly front-loaded sentence with no filler. Every word contributes to communicating the primary action and object. It is as concise as possible without losing 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?

This is a simple one-parameter tool with a fully documented schema, so the description does not need to explain parameter details. However, because there is no output schema and no annotations, the description leaves an agent without guidance on expected outcomes, error conditions, or whether deletion is permanent. It is minimally adequate but incomplete for a destructive 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 coverage is 100% and the only parameter, uuid, is already described as 'Token UUID to delete.' The description adds no semantic value beyond the schema, so it stays at the baseline for high schema coverage. The required nature and additionalProperties: false are already captured structurally.

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

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

The description 'Delete an API token' clearly identifies the action (delete) and the resource (API token), making it straightforward even among siblings like api_tokens_list and api_tokens_create. It is specific enough to distinguish the tool's core intent, though it does not elaborate on scope or side effects.

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 guidance about when to use this tool versus alternatives, such as api_tokens_create or api_tokens_list. There are no exclusions, prerequisites, or context about how deletion fits into a workflow. The only signal is the verb 'delete,' which weakly implies the use case.

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?

Annotations are not provided, so the description carries the full burden of behavioral disclosure. It only states the action and resource without mentioning potential side effects, authentication requirements, return format, pagination, or any rate limits. For a listing operation, the behavior is mostly self-evident, but the description offers no additional context beyond the bare action.

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

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

The description is a single concise sentence that is immediately clear and front-loaded. It contains no unnecessary words or fluff, making it an efficient and well-structured definition.

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

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

For a simple no-parameter list tool, the description is minimally adequate, but it leaves out useful context such as the expected return shape (e.g., an array of token objects) and whether authentication is required. Since there is no output schema, the description could have provided a hint about the response format. It is complete enough for a straightforward call, but could be richer.

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

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

The tool has zero parameters, and the schema is an empty object with 100% coverage. With no parameters to explain, the description does not need to add parameter details. Baseline 4 is appropriate because there is nothing to clarify, and the description correctly omits any parameter-related content.

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

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

The description 'List all API tokens' clearly states a specific verb ('list') and resource ('API tokens'), distinguishing it from sibling tools like api_tokens_create, api_tokens_delete, and api_tokens_scopes_list. The purpose is unambiguous even without examining the schema or 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 is provided on when to use this tool versus alternatives. It does not mention related tools such as api_tokens_scopes_list or explain under what circumstances one might prefer listing scopes over tokens. For a simple list tool, this guidance is not strictly necessary, but the dimension asks for explicit usage context, which is absent.

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' clearly indicates a read-only operation, which is a behavioral trait. But it doesn't disclose any additional details like whether the list is exhaustive, sorted, or includes deprecated scopes. For a simple listing tool, minimal behavioral disclosure may be acceptable, but it provides no extra context beyond what 'List' implies.

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, complete sentence that is front-loaded with the action and resource. There is no redundancy or unnecessary detail. It is appropriately concise for a zero-parameter list operation.

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

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

For a zero-parameter, read-only list tool, the description is essentially complete. The agent knows what the tool does and can call it without any additional input. The lack of output schema is not a major gap since the description implies a list of scopes. It could mention the return format, but for this simple case it is not critical.

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

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

The tool has zero parameters, so the schema is trivially covered (100%). The description doesn't need to add parameter details since there are none. Baseline 4 is appropriate as no parameter complexity exists, and the description is sufficient.

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 ('List') and a specific resource ('all valid API token scopes'), which distinguishes it from other api_tokens_* siblings (list all tokens vs. list scopes). However, it doesn't explicitly contrast itself with api_tokens_list, so some ambiguity remains for an agent choosing between them.

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

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

The description does not provide when-to-use guidance or explicit alternatives. However, the context of listing scopes implies it should be used when an agent needs the set of valid scopes for creating or validating tokens, not when listing tokens themselves. This is implied but not stated, so it's not as strong as an explicit directive.

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 states the tool checks authentication status but doesn't describe what the check entails (e.g., returns user info, session validity, permissions), whether it requires authentication itself, or any side effects. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action ('Check current authentication status'), making it easy to parse. Every part of the sentence contributes 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?

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is minimally adequate. It explains what the tool does but lacks details on behavior, output format, or usage context. For a simple status-check tool, this is borderline viable but leaves room for improvement in guiding the agent.

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

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

The tool has 0 parameters, and schema description coverage is 100% (empty schema). The description doesn't need to add parameter semantics, so it meets the baseline of 4 for tools with no parameters. No additional parameter information is required or provided.

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

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

The description clearly states the tool's purpose with a specific verb ('Check') and resource ('authentication status'), specifying it relates to the 'Remnawave panel'. It distinguishes itself from siblings by focusing on authentication status rather than user/host/node management. However, it doesn't explicitly differentiate from potential authentication-related siblings (none exist in the list).

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

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

No guidance is provided on when to use this tool versus alternatives. The description implies it checks authentication status, but doesn't specify scenarios (e.g., before performing operations, troubleshooting login issues) or prerequisites. Without explicit usage context, the agent must infer when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It discloses the data aggregation (top per-user) but does not specify potential side effects (likely read-only), rate limits, or how results are ordered/truncated. The absence of annotations and output schema leaves behavior opaque.

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, concise sentence that front-loads the core action and resource. No redundancy or filler; it's appropriately sized for the complexity.

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 moderately complex with 4 parameters and no output schema. The description covers the basic purpose but lacks behavior details like response format, ordering, and whether topUsersLimit is inclusive. With no annotations, an agent might need to infer pagination behavior.

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

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

Schema coverage is 100%, so parameters are already documented. The description adds context for 'nodesUuids' and 'date range' but does not explain the meaning of 'topUsersLimit' beyond the schema. Baseline 3 is appropriate given full schema coverage.

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

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

The description clearly states the action ('Get'), the resource ('top per-user bandwidth usage'), and the scope ('across the given nodes for a date range'). It differentiates from general bandwidth tools like system_bandwidth_stats by focusing on per-user node-specific data, but doesn't explicitly name alternatives.

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

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

The description implies a reporting/analytics context, but provides no explicit guidance on when to use this tool versus alternatives like system_bandwidth_stats or hwid_top_users. The sibling list includes many bandwidth-related tools, but no exclusions or alternative suggestions 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 provided, the description carries full responsibility for behavioral disclosure. It only states the operation 'create', implying a mutation, but does not mention any side effects, required authorizations, data persistence, or potential errors. This is a significant gap for a write operation.

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

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

The description is a single, concise sentence with no unnecessary words. It is appropriately brief for a simple creation tool, though it could benefit from a bit more contextual detail without becoming verbose.

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

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

Given the simple nature of the operation, the schema coverage is complete, and there is no output schema to explain, the description is minimally sufficient. However, it lacks context on what a billing history entry is, how it relates to billing providers, or any validation rules, leaving some ambiguity for the agent.

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

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

Schema description coverage is 100%, so each parameter (amount, description, providerUuid) has a minimal description in the schema. The tool description adds no additional meaning beyond what the schema provides, and does not clarify units, formats, or relationships between parameters. Baseline 3 is appropriate since the schema handles documentation.

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

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

The description 'Create a billing history entry' clearly states the action (create) and the resource (billing history entry), which distinguishes it from sibling tools like billing_history_list and billing_history_delete. It is specific enough for an agent to understand the primary operation, though it lacks detail on what constitutes a billing history entry.

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, no prerequisites, and no mention of conditions under which creation is appropriate. The description provides no context about the relationship to billing providers or nodes, leaving the agent to 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 full behavioral burden. It states only 'Delete' without disclosing permanence, side effects, permission requirements, or any consequences. Since deletion is inherently destructive, the lack of such context is a notable gap.

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

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

The description is a single, concise sentence that conveys the entire purpose with zero extraneous words. It is front-loaded and efficient.

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

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

Given this is a destructive mutation with no annotations and no output schema, the description lacks essential context such as whether deletion is permanent, what the response indicates, or any prerequisites. A more complete description would warn about irreversibility and clarify expected outcomes.

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

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

The input schema has 100% description coverage for the single parameter (uuid as 'History entry UUID'). The description adds no semantic value beyond the schema, so the baseline score 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 'Delete a billing history entry' is a specific verb+resource combination. It clearly differentiates from sibling tools like billing_history_create and billing_history_list, leaving no ambiguity about its function.

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

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

While the description implies when to use this tool (for deletion), it does not provide explicit guidance on alternatives or exclusions. There is no mention of when-not-to-use or any comparison to related billing history tools, so usage is left 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 burden of behavioral disclosure. It only states the action 'list' and offers no information about side effects, permissions, return format, pagination, or whether the operation is read-only. For a list operation, this is a significant omission; the agent has no expectations about what to expect.

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

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

The description is a single concise sentence that is front-loaded with the action and resource. There is no wasted verbiage, and it is appropriately brief for a simple tool. However, it may be too terse to convey sufficient information, but conciseness itself is well-executed.

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

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

Given that this is a list operation with no parameters, no output schema, and no annotations, the description is severely underspecified. It does not mention what the billing history contains, how results are ordered, whether pagination exists, or what the response structure looks like. An agent calling this tool would have no expectations about the data returned, which is a major gap.

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

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

The tool has zero parameters and an empty schema. Per the rubric, a baseline of 4 applies to tools with no parameters, as there is nothing for the description to explain. The description adds no parameter-specific meaning, but given the lack of parameters, this is acceptable.

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 a resource 'billing history', clearly indicating its function. It is distinct from siblings like billing_history_create and billing_history_delete, and no other list tool exists for this resource. However, it is minimal and does not elaborate on the contents or scope of the history, which keeps it from being 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 use this tool versus alternatives. While no direct alternatives for listing billing history exist, the description does not mention that it is the sole retrieval method, nor does it provide any context about prerequisites, typical use cases, or relationship to other billing tools. This leaves the agent without explicit usage direction.

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 must carry the full burden of behavioral disclosure, but it only says 'create', which is barely more than the tool name. It does not explain what happens upon creation, such as whether a provider must already exist, whether an existing node is overwritten, or if billing starts immediately. This is a significant transparency gap for a mutation operation.

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

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

The description is a single, focused sentence with no unnecessary words. It is as concise as possible for a simple create operation, even though it lacks depth.

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 create operation with no annotations and no output schema, the description is overly sparse. It does not explain what a billing node is, any prerequisites (e.g., provider existence), or the meaning of the optional pricePerMonth in context. An agent would have to infer too much from the tool name and sibling list.

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

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

The input schema provides descriptions for all three parameters (nodeUuid, providerUuid, pricePerMonth) with 100% coverage, so the schema already carries the parameter meaning. The description adds no further semantic detail, 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 specific verb and resource: creating a billing node. It clearly distinguishes this tool from siblings like billing_node_update and billing_node_delete through the 'create' verb. However, it does not explicitly differentiate itself from nodes_create, which could be confusing in the context of a large sibling list.

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

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

There is no guidance on when to use this tool versus alternatives such as billing_node_update or billing_nodes_list. The description only states the action, providing no context about prerequisites or decisions on which tool to select. This leaves the agent without any routing information.

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

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

With no annotations provided, the description must carry the full behavioral burden. It conveys that the operation is destructive, but it does not disclose whether deletion is permanent, whether it cascades to related billing records, or whether any confirmation is needed. This is a significant transparency gap for a delete operation.

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

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

The description is extremely concise with no filler words, and the core action is front-loaded. However, the brevity comes at the cost of omitting important behavioral context, so it is efficient but not fully 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?

Although the tool has only one required parameter and no output schema, it is a destructive operation with no annotations. The description lacks any mention of permanence, related side effects, or conditions for safe usage, leaving the agent under-informed for a potentially impactful call.

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

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

Schema description coverage is 100%; the single uuid parameter is already described as 'Billing node UUID'. The description adds no additional meaning beyond the schema, so the baseline score 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 ('Delete') and a specific resource ('a billing node'), which clearly identifies the operation. It is distinct from related siblings like billing_node_create and billing_node_update, though it does not explicitly distinguish itself from nodes_delete beyond the 'billing' qualifier.

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

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

There is no guidance on when to use this tool versus alternatives such as billing_node_update or nodes_delete, and no mention of prerequisites or side effects. The agent must infer usage solely from the tool name and resource type.

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

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

No annotations are provided, so the description must carry the full burden. It only states the action and resource, with no mention of pagination, sorting, auth requirements, or return format. For a list operation, this is minimal and lacks disclosure of any side effects or constraints.

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

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

The description is a single concise sentence, front-loaded with the verb and resource. There is no wasted text, making it appropriately sized for a tool with no parameters.

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

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

The description is adequate for a simple list operation, but it leaves ambiguity about what constitutes a 'billing node' versus a regular node, and it doesn't mention the response structure (e.g., whether it returns an array of objects or includes metadata). Given the lack of an output schema, more context would help the agent understand the result.

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

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

With zero parameters, the schema is trivially covered at 100%. The description adds no parameter information, which is unnecessary given the absence of parameters. The baseline of 4 applies because there is nothing to document.

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

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

The description 'List all billing nodes' uses a clear verb and resource, distinguishing it from generic 'nodes_list'. However, it doesn't clarify how billing nodes differ from regular nodes or from 'billing_providers_list', so it's 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?

There is no guidance on when to use this tool versus siblings like 'nodes_list' or 'billing_providers_list'. The description provides no context for selection, leaving the agent to infer usage.

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 must carry the behavioral disclosure burden. It only says 'update', which implies mutation but does not disclose side effects, whether changes are reversible, any required permissions, or what the response will be. For a mutation tool, this is a significant gap.

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

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

The description is a single short sentence with no fluff, which is efficient. However, it is so minimal that it borders on under-specification. It is appropriately concise for a simple tool, but it could have added more context without becoming verbose.

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

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

Given the lack of annotations and output schema, the description is insufficiently complete. It does not explain the effect of the update, whether only pricePerMonth is updated or if other fields are supported, or any constraints. An agent might call this tool without understanding the full impact, especially since it is 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?

The input schema already provides descriptions for both parameters (uuid and pricePerMonth), achieving 100% schema description coverage. The tool description adds no additional information about parameter usage, formats, or relationships. Therefore, the description adds no value beyond the schema, so a baseline score 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 the verb 'update' and the resource 'billing node', which is clear about the action. However, it does not distinguish from other update tools such as nodes_update or billing_provider_update, and it doesn't specify what aspects of the billing node are updated beyond what the schema hints at. The description is nearly a restatement of the tool name, so it provides minimal 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 guidance on when to use this tool versus alternatives. No mention of prerequisites, whether this is a partial or full update, or any conditions for using it. The agent must infer usage from the name and schema, which is minimal and lacks explicit 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 of behavioral disclosure. It only states the operation ('Create') but does not reveal what happens on success (e.g., whether it returns the created object), any side effects, idempotency, or required permissions. For a mutation tool, this is a significant gap.

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

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

The description is a single, front-loaded sentence with zero extraneous content. It efficiently conveys the core purpose without waste.

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

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

The tool is simple (2 parameters, no output schema, no nested objects), and the schema fully documents parameters. However, the description lacks any detail about return values, validation rules, or operational context (e.g., whether the provider must be linked to a billing node). While minimal, it is borderline adequate for a simple create operation, but a bit more context would help.

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

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

The input schema has 100% coverage, with both parameters (name and description) having basic descriptions. The tool description adds no extra meaning beyond the schema, so it meets the baseline for high coverage without enriching parameter understanding.

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

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

The description states a specific verb ('Create') and a clear resource ('billing provider'), which distinguishes it from sibling CRUD tools like billing_provider_update, billing_provider_delete, and list/get variants. The intent is unambiguous.

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

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

The verb 'Create' implies its use case: when a new billing provider is needed. However, there is no explicit guidance on when not to use it (e.g., if a provider already exists) or any mention of alternatives like update. The usage context is only implied, not 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. It only states the action without revealing whether deletion is permanent, irreversible, whether it cascades to related entities (e.g., billing nodes, history), or if special permissions are required. For a destructive mutation tool, this is a significant gap in transparency.

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

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

The description is a single short sentence with no wasted words, which is concise. However, it is so sparse that it lacks useful structure or front-loading of key behavioral caveats. It is appropriately terse for a simple operation, but it does not enrich the agent's understanding.

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

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

Given the tool's simplicity (one parameter, no output schema, no annotations), the description is incomplete. It does not cover side effects, irreversibility, idempotency, or any constraints that might influence call decisions. An agent needs more context to safely invoke a delete operation on a billing provider.

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

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

The input schema documents the single 'uuid' parameter with 'Provider UUID' at 100% coverage. Since schema_description_coverage is high, the baseline is 3. The description adds no additional meaning beyond what the schema already provides, but it does not need to compensate for any missing parameter documentation.

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

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

The description clearly states a specific verb and resource: 'Delete a billing provider'. It properly identifies the operation for the billing_provider_delete tool and distinguishes it from sibling tools like billing_provider_create or billing_provider_update by its action. However, it does not elaborate on what a 'billing provider' is, which is minimal but not misleading.

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

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

There is no guidance on when to use this tool versus alternatives, such as when not to delete a billing provider or what conditions must hold. No mention of prerequisites, consequences, or the relationship to other billing operations. The name implies the purpose, but the description does not provide explicit usage context or differentiate among the many delete tools in the sibling set.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states a read operation ('Get'), which implies no side effects, but does not disclose details like whether the provider is returned in full or partial, any error behavior (e.g., 404 if not found), or authentication requirements. It doesn't contradict annotations (none exist), but it adds minimal context beyond the 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, grammatically correct sentence with no unnecessary words. It is front-loaded with the action and resource. Perfectly concise for the tool's simplicity.

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-parameter read tool, the description is sufficient. The schema covers the parameter fullyaine, and there is no output schema to explain. The description notes the main action and identifier. It might be slightly more helpful to mention that the provider is returned entirely or that an error is thrown if not found, but these are minor gaps given the tool's simplicity.

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 documents the 'uuid' parameter as 'Provider UUID'. The description adds no further meaning beyond what the schema provides, so baseline 3 is appropriate. It doesn't enrich the parameter with format, examples, or constraints.

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

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

The description states a clear verb ('Get') and resource ('billing provider') with a specific identifier (UUID). It is distinct from siblings like billing_providers_list because it retrieves a single provider by UUID. However, it does not explicitly name the sibling for listing all providers, so it's clear but lacks explicit differentiation.

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

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

The description implies usage: use when you need a specific provider by UUID. It does not provide explicit when-to-use vs. alternatives, such as 'use billing_providers_list to retrieve all providers'. While the context of sibling tools suggests the distinction, the description itself offers no guidance on alternatives or when not to use it.

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

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

There are no annotations, so the description must carry the behavioral burden. It communicates a read-only enumeration operation and the 'all' scope, but it does not describe response format, pagination, access requirements, or potential costs. This is a modest gap for a parameterless list.

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 six-word sentence with no filler, tautology, or redundant phrasing. The verb and resource are front-loaded, making the purpose immediately clear.

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 list tool, the description is enough to invoke it, but there is no output schema and no description of what the returned provider objects look like. An agent knows it will get 'all providers' but not the shape or structure of the result.

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

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

The input schema is empty and schema description coverage is 100%, so there are no parameters requiring additional documentation. The zero-parameter baseline of 4 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 uses a specific verb ('List'), names a clear resource ('infrastructure billing providers'), and states the scope ('all'). It is distinct from the singular sibling `billing_provider_get`, which retrieves one provider.

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 wording implies this tool is for enumerating all billing providers, but it does not explicitly mention alternatives or when not to use it. An agent must infer the contrast with `billing_provider_get` and related billing tools.

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

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

With no annotations provided, the description bears full responsibility for disclosing behavior. It only says 'Update', implying mutation, but provides no details on side effects, permission requirements, reversibility, or what happens to unmentioned fields. This is a significant gap 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?

The description is a single sentence with no wasted words, but it is extremely minimal. It conveys the verb and resource but lacks any structural elaboration. It is not 'under-specified' to the point of a tautology, but it is barely 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 simple update tool with three parameters and no output schema, the description provides almost no context beyond the action word. It omits details about how the provider is identified (uuid is in schema), what fields can be updated (already in schema), and any behavioral notes. Given the lack of annotations, this is incomplete for safe usage.

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

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

Schema description coverage is 100%, so the input schema already documents all three parameters (name, description, uuid). The description adds no extra meaning beyond what the schema provides, but the schema does the heavy lifting, so a 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 the verb 'Update' and the resource 'billing provider', making the core action clear. It distinguishes from sibling read/delete/create tools by the verb, though it does not explicitly differentiate from other update tools like billing_node_update.

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

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

No guidance is given on when to use this tool versus alternatives such as billing_provider_create or billing_provider_delete. There is no mention of context, prerequisites, or conditions that would select this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Create a new config profile', which implies mutation but does not describe side effects, required permissions, return values, or any constraints. This is a minimal disclosure that leaves out critical behavioral context.

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

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

The description is a single sentence, which is concise and front-loaded. However, it is extremely terse, bordering on under-specification. Every word earns its place, but the description could provide more useful information without sacrificing brevity.

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 create operation with one required parameter and no output schema, the description lacks essential context such as what a config profile represents, whether the name must be unique, or what the response will look like. This is incomplete for an agent to understand the full behavior.

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

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

The schema fully documents the single parameter 'name' with the description 'Profile name', providing 100% coverage. The tool description adds no additional meaning beyond the schema, so the baseline score 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 ('Create') and resource ('config profile'), which clearly identifies the action. It distinguishes from sibling actions like update and delete, but does not explicitly name alternatives or provide differentiation beyond the verb.

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

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

No guidance is given on when to use this tool versus alternatives such as config_profiles_update or config_profiles_delete. The context of creating a new profile is implicit, but there is no explicit mention of use cases, exclusions, or prerequisites.

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

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

No annotations are present, so the description must disclose behavioral traits. It merely states 'Delete', implying destructive action, but fails to mention irreversibility, side effects (e.g., impact on nodes or users using the profile), permission requirements, or cascading behavior. This is a significant gap for a destructive operation.

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

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

The description is a single, clear sentence with no waste. It is appropriately sized for a simple operation. However, it lacks any additional structure or emphasis on key points, though that's not a major issue given the brevity.

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 a single parameter and no output schema, the description is incomplete. It omits behavioral context such as irreversibility, prerequisites, or consequences. An agent cannot fully gauge the risk or proper usage from the description alone.

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

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

The schema covers 100% of parameters with a description ('Profile UUID'), so the baseline is 3. The description adds nothing beyond the schema—it doesn't clarify the format, constraints, or how to obtain the UUID. With full schema coverage, a 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 clearly states the verb and resource: 'Delete a config profile'. It distinguishes itself from siblings like config_profiles_list, config_profiles_get, config_profiles_create, etc., by naming the delete action, though it doesn't explicitly contrast itself. The purpose is unmistakable.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or conditions. An agent receives no context about when deletion is appropriate or what to check before calling it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get' implies a read operation, but there is no mention of error behavior (e.g., UUID not found), return format, or any side effects. For a simple retrieval this is a minimal but incomplete 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, efficient sentence with zero wasted words. The key identifier (UUID) is front-loaded and the structure is clean for a simple retrieval 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 one-parameter get tool with no output schema and full schema coverage, the description is largely sufficient. The only gap is lack of return-format details, which is a minor omission for such a simple 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 uuid parameter is already documented in the schema. The description's 'by UUID' phrasing aligns with the parameter but adds no additional meaning beyond what the schema provides, 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 specific verb and resource ('Get a config profile by UUID'), which clearly indicates a retrieval operation. However, it doesn't explicitly distinguish itself from sibling get-variants like config_profiles_get_inbounds or config_profiles_get_computed_config, though the 'by UUID' qualifier helps narrow the scope.

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

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

No guidance on when to use this tool versus alternatives. There is no mention of config_profiles_list for enumeration, or the other get variants, and no context about when a single profile lookup is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the configuration is computed on-the-fly, whether it reflects current node/inbound state, whether it can be expensive, or what the response shape is. 'Get' implies read-only, but the distinctive 'computed' behavior is left entirely unexplained.

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 seven-word sentence with no waste; the verb and object are front-loaded. It is efficient, though its brevity borders on under-specification given that the key concept 'computed' goes 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?

For a one-parameter tool with a fully documented schema, the baseline completeness requirement is low. However, there is no output schema and no annotations, and this description does not explain what the returned computed configuration contains, how it differs from the plain profile, or when it is meaningful. It is minimally adequate but leaves the central concept opaque.

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% — the single required 'uuid' parameter is documented as 'Config profile UUID' in the schema. The description adds no parameter information, but the baseline of 3 applies because the schema already fully handles parameter semantics for this one-parameter tool.

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

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

The description states a clear verb ('Get'), resource ('computed configuration'), and target ('config profile'), so an agent knows what the tool does at a glance. It is distinguishable from siblings config_profiles_get and config_profiles_get_inbounds by the 'computed' qualifier, but the description never explains what 'computed' means, leaving some of the differentiation to the tool name itself.

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

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

No guidance is given on when to use this tool versus the closely related config_profiles_get, config_profiles_get_inbounds, or config_profiles_list. There are no exclusions, prerequisites, or hints about the scenario where a 'computed' configuration is needed, so an agent must infer the selection logic entirely from naming.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get inbounds' with no mention of read-only nature, permissions, side effects, or what constitutes 'inbounds'. This is a significant gap for a tool with zero annotation coverage.

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

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

A single succinct sentence with no fluff. The action is front-loaded and the tool is simple, so the brevity is appropriate.

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

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

The description does not clarify what 'inbounds' refers to in this context, what the output looks like, or any dependencies. With no output schema, it should at least hint at the return value. The lack of context makes it incomplete for an agent trying to use it correctly.

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

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

Schema coverage is 100% with the uuid parameter described as 'Config profile UUID'. The description adds no additional semantics beyond what the schema provides, 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 specific verb (Get) and resource (inbounds for a specific config profile). It is clear and distinct from config_profiles_get (which likely returns the profile itself) and inbounds_list (which returns all inbounds). However, it does not explicitly name or differentiate these siblings, 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?

No guidance on when to use this tool versus alternatives like config_profiles_get or inbounds_list. The description doesn't mention any conditions, prerequisites, or exclusion criteria, leaving an agent to guess which getter to call.

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 states it's a list operation, implying read-only behavior, but doesn't specify whether it returns all profiles, supports pagination, requires authentication, or has rate limits. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence ('List all config profiles') that is front-loaded and wastes no words. It directly communicates the core purpose without unnecessary elaboration, making it easy for an agent to parse quickly.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'config profiles' are, what the return format looks like, or any behavioral traits like authentication needs. For a tool in this context with no structured support, the description should provide more context to be fully helpful.

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

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

The input schema has 0 parameters with 100% coverage, meaning no parameters are documented in the schema. The description doesn't add parameter details, which is appropriate since there are none. It accurately reflects the lack of parameters by not mentioning any, earning a high baseline score for tools with zero parameters.

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

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

The description clearly states the verb ('List') and resource ('config profiles'), making the purpose immediately understandable. It distinguishes itself from siblings like 'hosts_list' or 'users_list' by specifying 'config profiles' as the target resource. However, it lacks specificity about what 'config profiles' are in this context, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., after authentication), or comparisons to similar list operations like 'hosts_list' or 'users_list'. Without any usage context, the agent must infer when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It fails to mention that this is a mutating operation that overwrites ordering, whether partial arrays are allowed or all profiles must be included, or any side effects. The agent is left to infer these traits.

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

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

The description is a single concise sentence with no filler, and the core action is front-loaded. It is appropriately sized for the tool's simplicity.

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 behavioral context. The description does not explain the effect on existing positions, whether the operation is atomic, what the response looks like, or if there are constraints like requiring all profiles. This is insufficient for a mutation tool with nested parameters.

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% because both uuid and viewPosition have descriptions. The description merely restates the parameter intent ('new position') without adding any extra semantic detail such as uniqueness constraints, array length requirements, or ordering guarantees, so it adds no value beyond the schema.

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

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

The description clearly states the specific action (reorder) and resource (config profiles), plus the method (by supplying UUIDs with new positions). This distinguishes it from other config_profiles_* tools and from reorder tools for other entities.

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

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

No explicit when-to-use or alternative guidance is provided. The tool name strongly implies it is for reordering config profiles, but the description does not state when to prefer this over related operations like config_profiles_update, nor does it mention any exclusions or preconditions.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure, but it only says 'Update a config profile.' It does not state whether the update is partial or full replacement, how the optional 'config' field is handled, what side effects may occur, or whether changes are reversible.

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 terse and front-loaded, but it is under-specified rather than appropriately concise; it essentially restates the tool name. A short phrase carrying no additional operational detail is closer to under-specification than to good 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?

There is no output schema and no annotations, so the description should clarify update semantics, prerequisites, return behavior, and side effects. None of that context is present. The schema covers parameters but not the behavioral context needed to invoke the tool confidently and 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%, with each parameter already documented ('New name', 'Profile UUID', 'Full Xray config object'). The description adds no parameter-level meaning beyond what the schema already provides, 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 clear verb and resource: 'Update a config profile.' This distinguishes it from sibling operations such as config_profiles_create, config_profiles_delete, config_profiles_list, and config_profiles_get. However, it is still generic and does not mention the updatable aspects (name, config object) beyond what the schema already provides.

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 config_profiles_create, config_profiles_delete, or config_profiles_reorder, and no mention of prerequisites such as the profile needing to exist. 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 burden. It discloses that the operation is asynchronous and returns HTTP 202, which adds useful context. However, it does not mention the destructive nature (dropping active connections can disrupt users), any required permissions, whether the action is reversible, or what happens to subsequently reconnecting users. For a potentially disruptive mutation, 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 that includes the action, targets, scope, and async behavior with '202'. Every piece adds information, and there is no filler or redundancy.

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

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

With no output schema and no annotations, the description covers the basic operation, but ambiguity remains about whether userIds and ipAddresses are combined or exclusive, and whether at least one is required. The async/202 note is present, but for a destructive tool it could mention that this is a forceful action with potential user impact. Overall, it is adequate but missing a few edge-case specifics.

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 all three parameters (userIds, nodeUuids, ipAddresses) already have descriptions. The tool description does not add additional semantics beyond the schema, such as the relationship between userIds and ipAddresses (AND/OR), or that at least one must be provided. The baseline of 3 is appropriate since the schema handles the parameter meanings and the description adds marginal value.

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

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

The description states a clear verb ('Drop'), a specific resource ('active connections'), and the two criteria (user IDs or IP addresses) plus scope (all or specific nodes). It distinguishes itself from sibling fetch and geocheck tools, so an agent can immediately tell this is a termination action.

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

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

The description implies its use case (when you need to force-disconnect users) but does not explicitly mention alternatives or conditions for when not to use it. The sibling list contains fetch and result-retrieval tools, which are clearly different from 'drop', but the description itself does not guide the agent in choosing between them or warn about destructive consequences.

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. It discloses two important behavioral traits: this is an asynchronous job and it returns a jobId. This goes beyond the tool name and schema, giving agents the essential operational context, even though it does not mention polling or result retrieval.

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 sentence that front-loads the action and scope, while appending the critical async/jobId detail. No wasted words.

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

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

Given the async complexity, the description adequately communicates the start of an async job and its jobId return. It does not explicitly instruct on polling or where to retrieve results, but sibling tool names like connections_get_node_result make the follow-up discoverable. This is reasonably complete for a fetch tool.

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

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

Schema description coverage is 100% for the single parameter nodeUuid, so the schema already fully documents the parameter. The description merely restates the concept of 'node' without adding format, constraints, or additional meaning 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?

Clearly specifies the verb 'Fetch' and the resource 'connections for all users on a node', which distinguishes it from the sibling 'connections_fetch_by_user'. The async behavior and return of jobId are also stated, leaving no ambiguity about what this tool does.

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

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

The description implies when to use it ('for all users on a node') and hints at async behavior, but it does not explicitly name alternatives or contrast with tools like connections_fetch_by_user or connections_get_node_result. Usage context is clear but no exclusions or when-not-to-use guidance is provided.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It does disclose the key asynchronous behavior and the jobId return, which goes beyond the schema. It omits details about how to retrieve the result, the lifetime of the job, or failure behavior, leaving an noticeable gap for an async job tool.

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

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

The description is a single sentence that front-loads the core action and resource, then tucks the essential async/jobId caveat into a parenthetical. Every word earns its place and there is no redundancy or filler.

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

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

For a one-parameter, no-output-schema tool, the description tells the agent the essential behavior: start an async job and receive a jobId. The sibling connections_get_user_result and the visible naming convention make the polling step reasonably discoverable, though explicitly referencing it would make the description fully complete.

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

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

The single parameter userId is fully documented in the schema as 'User numeric ID', giving 100% schema coverage. The description adds no additional parameter-level meaning, but none is needed at this level of coverage; 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 clearly identifies the action (fetch) and resource (active connections for a user), and the parenthetical adds an important qualifier that it is an async job returning a jobId. It is distinguishable from sibling tools by the by_user naming and the explicit async behavior, though it does not explicitly contrast with connections_fetch_by_node or connections_get_user_result.

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 'async job, returns jobId' implicitly tells the agent that this tool initiates a polling workflow rather than immediately returning connection data. However, it does not explicitly state that connections_get_user_result should be called afterward, nor does it mention any exclusions or alternative selection criteria.

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 bears the full burden. It discloses the async nature ('async job') and a version constraint ('requires node 3.3.0+'), which is useful. However, it does not explain what happens on failure, how results are obtained, or the response structure. Lacks critical behavioral details for an async operation.

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

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

The description is a single, compact sentence that front-loads the core action. It avoids redundancy and is efficient, though it omits useful context like result retrieval.

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 no output schema and async behavior, the description should mention how to obtain results (e.g., via connections_get_geocheck_result) and any prerequisites. The version note is helpful, but the missing relationship to result retrieval leaves a gap for agent execution.

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

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

Schema description coverage is 100%, so all parameters already have descriptions. The tool description adds no extra parameter semantics, which aligns with the baseline of 3 when the schema handles parameter documentation.

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

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

The description clearly states the action ('Run a geolocation check') and the resource ('from a node'), which is specific and distinguishes it from fetching results. However, it does not explicitly differentiate from sibling tools like connections_get_geocheck_result, though 'async job' hints at the 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?

The description notes the async nature and the version requirement, which gives context on when to use it. It does not explicitly mention alternatives or when not to use it, such as referencing connections_get_geocheck_result for retrieving results. The guidance is implied but not explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state that this is a read-only operation, what the result looks like, or whether it is idempotent. The description is too terse to convey any behavioral traits beyond the literal 'get'.

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

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

The description is a single, concise sentence with no wasted words. It is front-loaded with the action and resource, making it easy to parse.

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

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

Given the simplicity (one parameter, no output schema), the description is minimal but leaves gaps. It does not explain the workflow (e.g., that this retrieves results after starting a geocheck), nor does it describe the return format, which the agent needs to know since there is no output schema.

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

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

The schema description coverage is 100%, and the parameter jobId is adequately described as 'Job ID from connections_geocheck'. The tool description adds no additional semantic information beyond the schema, 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 clearly states the action ('Get result') and the resource ('a geocheck job'), which distinguishes it from the sibling connections_geocheck (which starts a job). However, it does not explain what 'geocheck' means, leaving some ambiguity for agents unfamiliar with the domain.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that it should be called after connections_geocheck, nor does it clarify differences from connections_get_user_result or connections_get_node_result.

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, but it only states that a result is fetched. It does not mention whether the job may still be running, whether the result is polled or one-shot, what happens if the job is missing/expired, or what the returned payload looks like.

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 filler or repetition. It conveys the core action and resource efficiently.

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 job-result retrieval tool with no annotations and no output schema, the description is too sparse. It does not explain how to obtain a job ID, how to interpret the result, whether retries are needed, or how this fits with the connections_fetch_by_node workflow.

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%: the single parameter jobId is already documented as 'Job ID from connections_fetch_by_node'. The tool description adds no additional parameter meaning, so it is correctly at the baseline for high schema coverage.

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

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

The description names a specific verb ('Get') and resource ('result of a node connections fetch job'), and the word 'node' distinguishes it from the analogous user-result tool. It could be slightly stronger by explicitly naming the companion fetch tool, but the intent is clear.

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 explicit guidance on when to call this tool versus alternatives like connections_get_user_result, nor does it state that it should be used after connections_fetch_by_node. The only contextual hint is indirect, via the jobId parameter description in the schema.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get result' which implies a read operation, but it does not mention whether the job may still be running, whether the tool blocks or errors on incomplete jobs, or any side effects. This is insufficient for an agent to understand the tool's runtime behavior.

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

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

The description is a single concise sentence with no redundant words, which is efficient. It does not waste space, though it is minimal to the point of lacking necessary context. It is appropriately short for a simple tool, but could be more informative without becoming verbose.

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

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

Given the tool is a 'get result' operation likely tied to an asynchronous fetch job, the description omits crucial context such as how to check if the job is complete, what happens if the jobId is invalid, and the expected format of the result. With no output schema and no annotations, the description is too sparse to fully guide an agent in correct invocation.

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

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

The input schema already documents the parameter 'jobId' with a description, and coverage is 100%. The tool description does not add any extra meaning beyond the schema, so it aligns with the baseline score of 3 for cases where schema coverage is high and the description adds no additional insight.

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 ('Get result') and a specific resource ('user connections fetch job'), making it clear what operation is performed. However, it does not explicitly differentiate from the sibling tool connections_get_node_result, which is analogous for node jobs, so it is not fully distinguishable without relying on the name.

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

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

The description provides no explicit guidance on when to use this tool or how it relates to connections_fetch_by_user. While the parameter schema hints that a jobId comes from connections_fetch_by_user, there is no statement about polling, waiting for completion, or alternatives like connections_get_node_result. This leaves the usage context largely implicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that the operation is asynchronous via '(async 202)', which is useful, but it does not explain what this means for the caller (e.g., no immediate result, need for polling), nor does it mention side effects, reversibility, or permission requirements. For a mutation tool, this is a significant gap.

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

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

The description is a single, front-loaded sentence with no wasted words. The key scope ('ALL users') and the notable async behavior are both included, making it appropriately concise for a one-parameter tool.

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

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

The tool is a mutating operation with no annotations, no output schema, and an async result, yet the description only states the action and the HTTP status code. It does not explain what the caller should expect after the 202 response, whether users are added immediately or eventually, or how failures surface. This is incomplete for safe invocation.

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

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

Schema description coverage is 100%, so the single parameter squadUuid is already documented as 'Squad UUID'. The description adds no parameter-level meaning beyond this, but it also does not need to because the schema fully covers the only 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?

The description states a specific verb ('Add'), a precise scope ('ALL users'), and a distinct resource ('external squad'), immediately distinguishing this from squads_add_all_users and targeted add operations. It is more informative than the tool name alone and clearly specifies what the operation accomplishes.

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 about when to choose this tool over alternatives or when not to use it. It does not mention that non-all user additions require a different tool, nor distinguish this from squads_add_all_users. The behavior is implied but not explicitly framed relative to sibling 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 present, so the description carries the full burden of behavioral disclosure. 'Create' implies a state change, but the description does not disclose uniqueness constraints, idempotency, permissions, or side effects, and there is no output schema to indicate what is returned.

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 filler or redundancy. Every word earns its place given the simple one-parameter 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 a one-field create operation, the description is nearly sufficient, but the lack of annotations and output schema leaves the agent without behavioral or return-value context. It does not say whether creation requires special permissions or what happens if the name already exists.

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%: the only parameter, name, is documented as 'Squad name'. The description adds no additional meaning beyond 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 specific action ('Create') and a specific resource ('external squad'), matching the tool name and distinguishing it from sibling tools like external_squads_list, external_squads_update, and squads_create. There is no ambiguity about what operation is performed.

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

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

No guidance is given for when to choose this tool over external_squads_update or squads_create; the description only repeats the creation intent. The sibling list is the only signal, and it is left to the agent to infer the differences.

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 alone must disclose the destructive nature of this operationichel including irreversibility, cascading effects on users, or permission requirements. The description only says 'Delete an external squad' with no elaboration, which is inadequate 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?

The description is a single minimal sentence with no wasted words, and it is appropriately sized for a simple delete operation. While it adds little beyond the tool name, it is well-structured and front-loaded.

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

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

For a delete tool with no annotations and no output schema, the description lacks essential context such as return behavior, error conditions, or destructive consequences. It is too sparse to fully inform an agent about the operation's 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 coverage is 100% and the only parameter 'uuid' is described as 'Squad UUID'. The description adds no extra meaning beyond the schema, so the baseline score 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 clearly states a specific action ('Delete') and a specific resource ('external squad'), which distinguishes it from similar sibling tools like 'squads_delete' by the 'external' qualifier. It fully answers what the tool does in a straightforward way.

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

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

There is no guidance on when to use this tool versus alternatives such as 'squads_delete' or 'external_squads_get'. The description does not offer context, prerequisites, or typical use cases, so the agent has to infer when deletion is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals nothing about response format, error behavior, authentication requirements, or what distinguishes an external squad. The minimal text offers no behavioral context beyond the operation name.

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 concise sentence with the action front-loaded and no filler. Efficient, though it errs slightly toward under-specification rather than genuine 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 simple single-parameter get operation with a fully documented parameter, this is roughly adequate. However, with no output schema and no behavioral notes, an agent is left without information about what the return value looks like or edge-case behavior. Minor but 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?

Schema coverage is 100% for the single uuid parameter, whose schema description ('Squad UUID') already conveys its meaning. The description restates the same concept without adding format, scope, or context beyond what the schema provides. Baseline 3 applies 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 states a specific verb ('Get'), a specific resource ('external squad'), and the lookup key ('by UUID'). It is distinguishable from siblings like external_squads_list, external_squads_create, and the non-external squads_get, though it does not explicitly differentiate from them.

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 tool versus alternatives. Sibling external_squads_list and the regular squads_get both exist, and nothing in the description tells the agent why to prefer this one or what distinguishes an 'external' squad. No exclusions or when-not-to-use 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?

No annotations exist, so the description carries the full behavioral burden. It does indicate this is a read-only listing operation, but it does not disclose anything about pagination, ordering, response shape, or whether all fields are returned. This is minimally acceptable but not rich.

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 zero filler. Every word earns its place for a simple list operation.

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 list tool, the description is mostly sufficient, but with no output schema and no annotations, it leaves unstated what the returned list contains and whether results are limited or complete. This is a minor but 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 has zero parameters, so the schema is trivially complete. The description does not need to explain parameter semantics, and the baseline of 4 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 uses a specific verb and resource: 'List all external squads'. It clearly distinguishes this from the sibling `squads_list` by using the 'external' qualifier, though it does not explicitly name or contrast any sibling 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?

No guidance is given about when to use this tool versus alternatives such as `squads_list` or `external_squads_get`. The usage context is only implied by the verb 'list', with no exclusions, prerequisites, or alternative routing.

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

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

No annotations are provided, so the description carries the burden. It usefully discloses the async behavior ('async 202') and the full destructive scope ('ALL users'), but it does not state reversibility, permission requirements, or downstream impact of emptying the squad.

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 compact sentence with the key scope qualifier and async behavior front-loaded. No redundant words or filler.

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

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

For a one-required-parameter, no-output-schema tool, the description is nearly sufficient: it identifies the resource, the destructive scope, and the async nature. It would be more complete with a short caution or alternative pointer, but nothing essential to invoking it is missing.

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

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

The single parameter squadUuid is fully covered by the schema ('Squad UUID'), so the description does not need to explain it. The description's 'external squad' wording adds slight context by clarifying which type of squad UUID is expected.

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 an unambiguous action ('Remove ALL users') on a specific resource ('external squad') and flags async 202 behavior. The scope word 'ALL' separates it from partial-removal variants, and 'external squad' differentiates it from squads_remove_all_users.

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?

Description gives the operation but no explicit when/when-not guidance or named alternatives. An agent must infer from the name/siblings (e.g., external_squads_add_all_users, squads_remove_all_users) when this is the right tool, so guidance is only implied.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It simply states 'Reorder external squads' without explaining whether the provided UUID array replaces the entire order, what happens to omitted squads, or whether any validation occurs. This is a mutation operation, yet the description gives no clues about side effects or constraints.

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?

While the description is extremely concise with no fluff, it is under-specified. A one-phrase description like this is not just concise but lacking in necessary detail, similar to a placeholder. It does not front-load critical information beyond the basic action.

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

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

For a simple one-parameter tool, the description is still incomplete. It does not explain the concept of 'external squads', the semantics of the ordering, or any expected outcomes. Without an output schema or annotations, the minimal description leaves an agent with too many unknowns to confidently invoke it correctly.

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

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

The input schema already provides a clear description for the single parameter: 'Ordered array of squad UUIDs' with 100% coverage. The tool description adds no additional meaning beyond that, so it aligns with the baseline of 3 for high schema coverage.

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

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

The description states a specific verb ('Reorder') and a specific resource ('external squads'), which distinguishes it from sibling reorder tools like squads_reorder, nodes_reorder, and hosts_reorder. However, it does not clarify what 'external squads' are or what the reordering affects (e.g., display order, priority), so some ambiguity remains.

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

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

There is no guidance on when to use this tool versus alternatives such as squads_reorder or other reorder tools. The description provides no context about scenarios that would call for reordering external squads specifically, nor any exclusions or prerequisites.

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

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

With no annotations, the description carries the full behavioral burden, but it only repeats the update action. It does not disclose whether the update is partial or full, what happens if the UUID does not exist, what permissions are needed, or what the response will be. This is minimal 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?

The description is a single, short sentence with no wasted words. However, it is so underspecified that it reads more like a restatement of the tool name than a substantive explanation, so the conciseness does not contribute much value.

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

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

The tool has no annotations, no output schema, and a two-parameter schema. The description does not explain external squad semantics, update behavior, error conditions, or why an agent should choose this over squads_update. The agent has enough to invoke the call only if it already knows the domain.

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 'name' described as 'New squad name' and 'uuid' as 'Squad UUID'. The description itself adds no parameter meaning, but the schema is sufficient, 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 uses a clear verb and resource: 'Update an external squad'. The 'external' qualifier distinguishes it from squads_update, and the verb separates it from external_squads_create/delete/list/get. However, it gives no specific detail about what an update entails beyond the general action.

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

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

There is no guidance on when to use this tool versus alternatives such as squads_update or external_squads_create/delete. No context, prerequisites, or exclusions are provided, so the agent must infer usage entirely from the name and schema.

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 conveys that the operation is destructive, but it does not disclose irreversibility, cascade effects, or what happens to associated resources or data beyond the literal 'delete'.

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 clean five-word phrase with no filler: verb first, then resource, then scope. Every word 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 one-parameter operation with full schema coverage, the description is minimally adequate. However, with no annotations and no output schema, the destructive side effects and result behavior remain implicit rather than explicitly stated.

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 the single parameter documented as 'Array of host UUIDs'. The description itself adds no parameter-level meaning beyond 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 specific verb ('delete') and resource ('hosts'), and the word 'bulk' clearly distinguishes it from the sibling hosts_delete. An agent can tell what this tool does 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?

There is no explicit 'use when' or 'instead of' guidance. The word 'bulk' implies this tool is for deleting multiple hosts versus hosts_delete, but no conditions, exclusions, or alternatives are named.

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 says hosts are disabled but does not disclose reversibility, whether the change takes effect immediately, partial-failure behavior, or permission requirements. 'Bulk disable' describes the action but not its side effects.

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

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

The description is one short sentence with no filler or repetition, and the key action is front-loaded. It is appropriately compact for a simple one-parameter tool, though the brevity borders on under-specification in other dimensions.

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

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

For a single-parameter mutation with complete schema coverage, the description is minimally adequate to invoke: pass uuids of hosts to disable. However, with no annotations and no output schema, it lacks information about return values, reversibility, and operational effects, leaving clear gaps that prevent a higher score.

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

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

Schema description coverage is 100%; the only parameter, 'uuids', is already described as 'Array of host UUIDs'. The description's phrase 'selected hosts' is a light paraphrase of uuids and adds no new semantics like format, constraints, or edge cases. With the schema doing the heavy lifting, 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 clear verb ('disable') and resource ('hosts'), and 'bulk' signals it operates on multiple selected records rather than a single host. It is distinguishable from sibling hosts_bulk_enable and hosts_bulk_delete by the operation word, though it does not explicitly call them out. Some detail about what 'disable' actually changes is omitted, so 4 rather than 5.

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

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

There is no guidance on when to choose this over hosts_bulk_enable, hosts_bulk_delete, hosts_bulk_update, or hosts_update. The only signal is the verb and 'bulk', which implies use for multi-host disable but gives no exclusions, alternatives, or prerequisites. This is effectively no guidance beyond the operation 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?

The description says 'Bulk enable selected hosts' but does not disclose any behavioral traits such as side effects, reversibility, idempotency, or whether it requires hosts to be disabled first. With no annotations, the description carries the full burden, and it fails to provide meaningful behavioral context.

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

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

The description is a single, focused phrase with zero wasted words. It is front-loaded with the action and resource, and no filler or redundant content exists.

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

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

For a mutation tool with no annotations and no output schema, the description is too sparse. It does not explain return values, error conditions, side effects, or how bulk enable relates to other host operations. The agent is left to infer critical context needed for correct invocation.

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

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

The schema already documents the only parameter ('uuids' as an array of host UUIDs) with 100% coverage. The description does not add any additional meaning about the parameter beyond what the schema provides, 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 clear action ('enable') on a specific resource ('hosts') and indicates bulk operation via 'Bulk', which distinguishes it from sibling tools like hosts_bulk_disable and hosts_delete. It lacks detail about what 'enable' means in this context, 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?

There is no guidance on when to use this tool versus alternatives such as hosts_bulk_disable or hosts_update. The description only states what it does, with no mention of prerequisites, exclusivity, or conditions under which another tool would be more appropriate.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It states the tool updates fields but does not explain side effects, partial-failure behavior, whether unset fields remain unchanged, idempotency, required permissions, or the response format. The replacement-endpoint note adds some historical context but not operational transparency.

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

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

One efficient sentence with zero filler. The core operation and the relevant removal context are front-loaded, and there is no redundant repetition of schema 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?

Despite a 16-parameter bulk mutation with nested objects and no output schema, the description provides only a single line. An agent lacks guidance on partial updates, constraints, result reporting, or failure modes. The rich schema partially compensates, but the overall tool context remains under-specified.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description adds no additional meaning about parameter usage, field interactions, or update semantics, 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?

States a specific verb ('Bulk update'), resource ('hosts'), and scope ('selected hosts'), and adds useful context by noting it replaces the removed set-inbound / set-port endpoints. This clearly identifies what the tool does and differentiates it from single-host or enable/disable bulk variants.

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

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

No guidance is given on when to use this tool versus alternatives like hosts_update, hosts_bulk_enable, hosts_bulk_disable, or hosts_bulk_delete. The only context is the replaced endpoint mention, which does not help an agent choose among current 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 burden of behavioral disclosure, but it only says 'Create a new host' – which is self-evident. It does not mention persistence, side effects, required permissions, idempotency, or any consequences of the mutation. This is a significant gap for a creation tool.

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

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

The description is a single, compact sentence that directly states the tool's purpose. It is front-loaded with the action and resource, with no filler or repetition. It earns its place and is appropriately sized for a simple action statement.

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

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

Despite the rich schema, the description lacks high-level context about what a host is, what is required to create one, or what the agent should know about the implications of the action. With no output schema and no annotations, the description alone is insufficient to fully guide an agent toward a correct invocation, especially given the complex nested parameters and enums.

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

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

The schema has 100% description coverage for all 21 parameters, so the baseline is 3. The description adds no parameter-level meaning beyond what the schema already provides, but it does not need to because the schema is thorough. It neither compensates nor detracts.

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 ('Create') and resource ('a new host in Remnawave'), clearly distinguishing this from sibling tools like hosts_update, hosts_delete, and hosts_list. The action is unmistakable and there is no ambiguity about what the tool does.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, when hosts_create should be preferred over hosts_bulk_create or hosts_update, or what scenarios call for it. The description simply states the action without contextual direction.

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 states 'Delete' which implies a destructive, irreversible mutation, but doesn't specify consequences (e.g., data loss, impact on associated resources), permissions required, error conditions, or response format. For a destructive operation with zero annotation coverage, this is inadequate.

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

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

The description is a single, direct sentence with zero wasted words. It front-loads the key action ('Delete') and resource ('host'), making it immediately understandable. Every word earns its place, and there's no redundancy or fluff.

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

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

Given the tool's complexity (a destructive deletion operation), lack of annotations, and no output schema, the description is insufficient. It doesn't cover behavioral aspects like irreversibility, side effects, or what happens on success/failure. For a tool that permanently removes resources, more context is needed to ensure safe and correct usage.

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

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

The input schema has 100% description coverage, with the single parameter 'uuid' documented as 'Host UUID to delete'. The description adds no additional parameter semantics beyond this. According to the rules, when schema coverage is high (>80%), the baseline score is 3 even with no param info in the description, which applies here.

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

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

The description clearly states the action ('Delete') and resource ('a host from Remnawave'), making the purpose unambiguous. It distinguishes from siblings like hosts_get, hosts_list, and hosts_update by specifying deletion rather than retrieval or modification. However, it doesn't explicitly differentiate from other deletion tools like nodes_delete or users_delete, which slightly limits sibling 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing the host's UUID), exclusions (e.g., not for deleting nodes or users), or contextual cues (e.g., use after hosts_list to identify targets). With multiple deletion tools in the sibling list, this lack of differentiation is a significant gap.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states it's a read operation ('Get'), but doesn't disclose error conditions (e.g., invalid UUID), authentication requirements, rate limits, or what data is returned. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence with zero wasted words. It front-loads the core purpose ('Get a specific host') and specifies the key identifier ('by UUID'), making it immediately actionable without unnecessary elaboration.

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

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

Given the lack of annotations and output schema, the description is insufficiently complete. It doesn't explain what a 'host' entails in this context, what data is returned, or potential side effects. For a tool that likely returns structured host data, more context is needed to guide effective use.

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

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

The description mentions 'by UUID', aligning with the single parameter 'uuid' in the schema. Since schema description coverage is 100% (the parameter is fully documented as 'Host UUID'), the description adds no additional semantic value beyond what the schema provides, meeting the baseline for high coverage.

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

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

The description clearly states the action ('Get') and resource ('a specific host by UUID'), making the purpose immediately understandable. It distinguishes this from hosts_list (which retrieves multiple hosts) but doesn't explicitly differentiate from other 'get' operations like nodes_get or users_get, which follow the same pattern.

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

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

No guidance is provided on when to use this tool versus alternatives. While the description implies it's for retrieving a single host by UUID, it doesn't mention prerequisites (e.g., needing a valid UUID), when not to use it (e.g., for listing hosts), or how it relates to siblings like hosts_list or hosts_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 full burden for behavioral disclosure. It states it's a list operation, implying read-only behavior, but doesn't specify whether it returns all hosts at once, uses pagination, requires authentication, has rate limits, or provides any metadata about the hosts. This leaves significant gaps for an agent to understand how to interact with it.

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

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

The description is a single, direct sentence that efficiently conveys the core purpose without any fluff. It's front-loaded and wastes no words, making it easy for an agent to parse quickly.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'hosts' are in this context, what data is returned (e.g., host names, IDs, statuses), or any behavioral aspects like pagination or errors. For a list operation with no structured output documentation, more context is needed.

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

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

The tool has 0 parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to explain parameters, and it correctly implies no inputs are required. A baseline of 4 is appropriate since there are no parameters to document.

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

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

The description clearly states the action ('List all') and the resource ('Remnawave hosts'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'hosts_get' (which presumably retrieves a single host) or 'nodes_list' (which lists a different resource type), so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'hosts_get' (for single host details), 'nodes_list' (for different resources), and 'users_list' (for user listings), there's no indication of context, prerequisites, or comparative use cases.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Reorder' implies mutation, but the description does not state whether the change is persistent, whether validation occurs, whether the operation is reversible, what the response looks like, or if partial orders are allowed.

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

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

The description is a single, direct sentence with no filler or redundancy. It front-loads the core action and the required input format, making it easy for an agent to parse quickly.

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

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

For a simple, one-parameter tool with a detailed schema, the description is minimally adequate. However, with no annotations and no output schema, it leaves out practical context such as return values, error behavior, or whether the operation is global or scoped, so it is not fully complete.

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

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

Schema description coverage is 100%, and the schema already documents 'Host UUID' and 'New position (0-based)' clearly. The description restates this idea without adding extra meaning, so it meets the baseline but does not enrich parameter understanding.

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

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

The description clearly states the action ('Reorder hosts') and the resource (hosts), with the specific mechanism of supplying UUIDs and new positions. It is unambiguous about what the tool does, though it does not explicitly contrast itself with nearby siblings like hosts_bulk_update or nodes_reorder.

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

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

The description provides no guidance on when to use this tool versus alternatives such as hosts_bulk_update or hosts_bulk_delete. There is no mention of prerequisites, whether all hosts must be supplied, or what scenarios call for reordering vs other bulk host operations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it lists host tags, but provides no information about sorting, pagination, response format, or whether any side effects occur. Since this is a read operation, no destructive behavior is implied, but the description adds no depth beyond the action itself.

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, succinct sentence with no redundant words. It effectively conveys the tool's purpose without fluff, achieving ideal 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?

Given that the tool takes no parameters and has no annotations, the description is almost sufficient. The absence of an output schema is mitigated by the common convention that a 'list' operation returns an array. For a tool this simple, the description covers the essential information an agent needs to invoke it, though slightly more context about the nature of host tags could be helpful.

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

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

The tool has zero parameters, so the schema necessarily covers them (100% coverage). The description does not need to describe parameters, and the baseline for 0 parameters is 4. There is nothing to clarify, and the description correctly omits parameter details.

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

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

The description 'List all host tags' states a specific verb (list) and a specific resource (host tags), and the 'all' indicates full scope. It is distinct from sibling tools like nodes_tags_list and users_tags_list, and from the more generic tags_list. Despite not explicitly naming alternatives, the resource specificity is unambiguous.

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

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

The description offers no guidance on when to use this tool versus alternatives like tags_list, nodes_tags_list, or users_tags_list. There is no mention of context, exclusions, or selection criteria. The agent must infer which tag-scoped list is appropriate based on the resource 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. 'Update an existing host' only implies a mutation; it does not clarify partial-update semantics (whether unspecified fields are preserved), idempotency, permission requirements, or the result of updating a non-existent host. For a 19-parameter mutation tool, this is a significant transparency gap.

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

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

The description is very concise, a single 5-word sentence with no fluff. However, it is arguably too terse for a tool of this complexity — conciseness is good, but the description essentially repeats the tool name 'hosts_update' rather than adding meaningful structured 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?

With 19 parameters, nested objects, no output schema, and no annotations, this is a high-complexity tool that a one-sentence description is completely inadequate for. The agent cannot determine update semantics, error behavior, or how nested fields like mapper and internalSquads interact with existing values, though the presence of hosts_get sibling could help partially compensate.

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 richly documents all 19 parameters including enums, nullability, and nested structures for mapper and internalSquads. The description adds no parameter-level meaning, but per the rubric the baseline 3 applies when the schema carries the weight; the description's lack of param hints is not penalized further.

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 ('Update an existing host') and is well-differentiated from siblings like hosts_create, hosts_delete, and hosts_get by the focus on updating an existing entity. However, it does not explicitly distinguish itself from hosts_bulk_update, leaving the agent to infer that this is the single-host variant.

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

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

The description provides no guidance on when to use this tool versus alternatives such as hosts_bulk_update or hosts_create, and it does not mention any prerequisites (e.g., the host must already exist, UUID must be valid). There is no exclusions or alternative routing, so the agent receives zero usage context beyond 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 present, so the description must carry the full burden of behavioral disclosure. It only states that the tool creates an entry, with no mention of side effects, permissions, idempotency, uniqueness behavior, or whether the user must already exist.

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

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

The description is one short, front-loaded sentence with no filler or redundant phrasing.

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

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

The tool is a mutation with no annotations and no output schema, yet the description does not mention expected return value, failure modes, or any behavioral caveats. The schema covers parameters, but contextual information needed for safe 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 the baseline applies. The description adds no parameter-level meaning beyond what the schema already provides.

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 action (Create), a specific resource (HWID device entry), and the target (a user). This clearly distinguishes it from sibling tools like hwid_device_delete and hwid_devices_list_all.

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 guidance on when to use this tool versus alternatives, nor does it state prerequisites or exclusions. It implies the obvious 'use to create a HWID entry' but provides no decision-making context.

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

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

With no annotations provided, the description must disclose behavior on its own. It clearly marks the destructive action 'Delete' and the composite identifier, but does not mention permanence, required permissions, error handling for nonexistent devices, or side effects. This leaves meaningful behavioral gaps for an agent.

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

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

A single, focused sentence that front-loads the action and the identifying key. No filler or redundant repetition, achieving an ideal size for this simple operation.

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

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

For a destructive operation with no annotations and no output schema, the description omits critical context: what the response looks like, whether the delete is irrevocable, and behavior when the device does not exist. While the two required parameters are clear, the operational consequences are left unknown for a tool that performs deletion.

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

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

The schema already fully describes both parameters (100% coverage) with 'Hardware ID to delete' and 'User numeric ID'. The description adds the composite-key framing but no extra semantic detail beyond what the schema provides.

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

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

The description states a specific action ('Delete'), a clear resource ('HWID device'), and precisely defines the identifier as 'user ID + hardware ID'. It is immediately distinguishable from siblings like hwid_device_create and hwid_devices_delete_all.

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 direct guidance on when to use this tool versus alternatives such as hwid_devices_delete_all. 'Specific' only implies single-device deletion; there is no explicit when-to-use, exclusions, or naming of related tools.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. This is a destructive bulk operation, yet the description offers no warning about irreversibility, side effects, permission requirements, or what happens to related data. This is a serious 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?

The description is a single, efficient sentence with no fluff, front-loading the core action. However, it is so terse that it omits crucial behavioral context, making it slightly under-specified for its purpose.

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 bulk delete operation with no output schema and no annotations, this description is dangerously incomplete. It fails to mention irreversibility, potential errors, prerequisites, or any post-condition, leaving an agent without the information needed to safely invoke it.

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

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

Schema coverage is 100% with only one parameter (userId) documented as 'User numeric ID'. The description adds no extra meaning beyond the schema, so it earns the baseline of 3 without further credit.

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: 'Delete all HWID devices for a user.' It clearly distinguishes from the sibling 'hwid_device_delete' (singular) by using 'all', so an agent can tell them apart without ambiguity.

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

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

No guidance is given on when to use this tool versus alternatives like hwid_device_delete for individual devices. It does not mention any conditions, exclusions, or context that would help an agent decide between bulk and singular deletion.

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

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

No annotations are provided, so the description must carry the full behavioral burden. 'List' implies a read-only operation, but the description discloses nothing about pagination, output shape, ordering, or behavior for missing users. It adds no behavioral context beyond the operation name itself.

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 filler, redundancy, or restating of the tool name. It is appropriately sized for a simple one-parameter list operation.

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 low-complexity single-parameter tool, the description states the essential scope, but it leaves gaps around return contents, pagination, and explicit differentiation from hwid_devices_list_all. With no output schema and no annotations, the description is minimally adequate rather than fully complete.

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

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

Schema description coverage is 100%, with userId documented as 'User numeric ID,' so the schema fully explains the only parameter. The description adds no parameter-level detail, but the baseline 3 is appropriate because the schema already covers the semantic weight.

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

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

The description uses a specific verb-resource pair ('List HWID devices') and the qualifier 'for a specific user,' which directly distinguishes it from the sibling hwid_devices_list_all. It clearly identifies both the resource and the scope of the operation.

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 qualifier 'specific user' gives clear context for when to call this tool: when you need HWID devices scoped to one user. It does not explicitly name alternatives or state when not to use it, but the sibling hwid_devices_list_all strongly implies the complementary all-devices case.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'List' makes the read-only nature clear and 'across all users' adds scope, but there is no mention of pagination, return shape, or any other noteworthy behavior. It is adequate but not richly transparent.

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

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

A single front-loaded sentence with no filler. Every word adds meaning: 'List', 'all', 'HWID devices', and 'across all users' are all necessary and sufficient.

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 list operation, the description is nearly complete: it conveys the action, resource, and scope. The lack of an output schema is mitigated by the fact that a list operation's response type is generally inferable, though an explicit note on return format or pagination would make it fully complete.

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

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

The tool has zero parameters and an empty input schema, so the description does not need to explain any parameter semantics. The baseline of 4 applies because nothing is left undocumented.

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'), resource ('HWID devices'), and scope ('across all users'). The 'all' and 'across all users' language clearly distinguishes it from the sibling `hwid_devices_list`, so an agent can tell which list tool matches the need.

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 scope 'across all users' implies when to use this tool, but it does not explicitly state when not to use it or point to alternatives such as `hwid_devices_list` for user-scoped listing. Usage is understandable but left mostly to inference.

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

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

With no annotations available, the description must carry the behavioral transparency burden, but it only says 'Get' which implies read-only. It doesn't disclose return format, data scope, performance implications, or any limitations, so it remains too thin for safety/cost assessment.

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 filler. It conveys the action and object in the minimum number of words, which is ideal for conciseness.

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

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

The description is too sparse for the tool's context. With no output schema, no annotations, and a vague term like 'statistics', an agent cannot tell exactly what it returns or how it differs from similar HWID endpoints. Key missing context is not compensated anywhere else.

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

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

The input schema is empty with zero parameters, so there is no parameter semantics to document. Per the calibration rule, a score of 4 is the baseline for a tool with no parameters.

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

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

The description states a clear verb ('Get') and a resource ('HWID device statistics'), which establishes the basic purpose. However, 'statistics' is ambiguous and doesn't differentiate this from closely related siblings like hwid_top_users or system_stats, so it stays 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?

No usage guidance is provided. The description doesn't mention when to choose this tool over hwid_devices_list_all, hwid_top_users, or other HWID/stats endpoints, and gives no context or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the basic purpose but does not disclose whether results are sorted, limited, or include zero-device users, nor does it describe the return format. This is a minimal description that leaves important behavioral aspects unspecified.

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

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

The description is a single, efficient sentence with no filler. It is front-loaded with the action and resource, and every word adds value.

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

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

For a zero-parameter tool with no output schema, the description provides the core purpose but omits details about ordering, limits, and the exact representation of 'users' in the response. It is minimally acceptable but could benefit from specifying that results are ranked by device count and whether a cap exists.

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

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

There are zero parameters, and the schema coverage is 100% (vacuous). Per the baseline for 0 parameters, a score of 4 is appropriate; the description does not need to explain parameters that don't exist.

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

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

The description clearly states the action (Get) and the resource (users), with a specific qualifier (with most HWID devices). It distinguishes itself from siblings like hwid_devices_list (which lists devices) and users_list (which lists all users) by focusing on ranking users by HWID device count.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer this over hwid_stats or users_list, nor does it indicate any context or prerequisites. An agent has to infer the use case 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. While 'List all inbounds' implies a read-only operation, it doesn't specify whether this requires authentication, has rate limits, returns paginated results, or what format the output takes. For a tool with zero annotation coverage, this is insufficient.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it immediately understandable without unnecessary elaboration.

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

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

Given no annotations, no output schema, and a simple listing tool, the description is incomplete. It doesn't explain what 'inbounds' are in this context, what data is returned, or any behavioral aspects like authentication requirements or response format. More context is needed for effective use.

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

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

With 0 parameters and 100% schema description coverage, the baseline is 4. The description doesn't need to explain parameters since there are none, and it correctly implies no inputs are required for this listing operation.

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

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

The description clearly states the action ('List all inbounds') and the resource ('from all config profiles'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'config_profiles_list' or 'nodes_list' that might list related resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or compare it to sibling tools like 'config_profiles_list' or 'nodes_list' that might serve similar listing purposes in different contexts.

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 burden of behavioral disclosure. It describes a generation action but does not explain whether this overwrites an existing key, whether it has side effects on node configuration, or whether it is reversible. Without any info on state change or return behavior, the agent cannot anticipate consequences.

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, succinct sentence that communicates the essential function without any extraneous words. It is appropriately sized for a zero-parameter tool and gets straight to what it does.

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

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

For a zero-parameter tool, the description is mostly complete: the agent knows the action and the domain. However, because there is no output schema and no annotations, key operational details are missing, such as what the generated key looks like, whether it is persisted or returned, and whether existing keys are invalidated. This gap is modest but leaves some uncertainty.

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

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

The tool has zero parameters)Skip the schema is trivially 100% coveredadian. The description correctly implies that no input is needed to generate the key. Since there are no parameters, no further semantic clarification is required, and a baseline of 4 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 uses a specific verb ('Generate') and names the resource ('SECRET_KEY for node configuration'). It clearly identifies the tool's purpose and distinguishes it from the sibling system_generate_x25519, which generates a different key type. It could be slightly clearer about what makes SECRET_KEY unique, but it is not a tautology.

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 guidance on when to use this tool versus alternatives like system_generate_x25519 or other node configuration tools. It does not state prerequisites, conditions, or scenarios where this tool should be preferred. The use case is implied but not explicitly framed.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. 'Get metadata' implies a read operation but does not state whether it is side-effect free, what the response shape is, or whether authentication or permissions are required. The description adds no insight beyond the literal action.

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 entire description is a single, focused sentence with no redundant words. It front-loads the action and resource, which is ideal for a one-parameter getter. No wasted space or filler.

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

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

For a simple one-parameter getter, the description plus full schema coverage is minimally adequate. However, the absence of an output schema and any guidance on return format or distinguishing from sibling metadata tools means the agent is left with incomplete context. It works for a trivial call but could be more informative.

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 the uuid parameter described as 'Node UUID' in the schema itself. The description's 'specific node' phrasing aligns with this but adds no new semantic detail about the parameter. Baseline 3 is appropriate given the complete schema coverage.

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

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

The description states a clear verb ('Get') and resource ('metadata for a specific node'), making it distinct from sibling metadata_user_get and metadata_node_upsert. While it doesn't explicitly differentiate from nodes_get, the 'metadata' qualifier provides enough specificity for basic disambiguation. A higher score would require naming an alternative or clarifying scope boundaries.

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

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

No guidance is provided about when to use this tool versus alternatives like nodes_get, metadata_user_get, or metadata_node_upsert. With a large sibling list containing many similar getters, the absence of any usage context leaves the agent to infer the appropriate selection. This is a clear gap.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Create or update' and does not clarify whether metadata is merged or fully replaced, what happens to existing metadata, or how errors like an unknown UUID are handled.

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

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

A single sentence with zero wasted words; the verb and target are front-loaded. It is appropriately sized for a straightforward upsert operation.

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 context an agent gets. It omits merge/replace semantics, error behavior, and any note that this is a mutating operation on node metadata, leaving meaningful gaps for a tool this simple.

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 both uuid ('Node UUID') and metadata ('Metadata key-value pairs') already documented in the schema. The description adds no parameter meaning 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?

States the precise verb ('Create or update') and resource ('metadata for a node'), which clearly differentiates it from siblings like metadata_user_upsert and metadata_node_get. The scope is unambiguous and immediately understandable.

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

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

No guidance is given on when to use this tool versus alternatives such as metadata_user_upsert or metadata_node_get. It does not state any conditions, prerequisites, or exclusions (e.g., that the node must already exist).

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