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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the read itself. It does not disclose ordering (newest-first?), whether entries are paginated, retention limits, or any authorization requirement for reading the audit log.

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

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

A single front-loaded sentence with zero filler; the resource and count are stated immediately. It is efficient, though so terse that it borders on under-specification rather than optimal 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 one-parameter read tool with no output schema, the description covers purpose and the count parameter adequately. It is nonetheless thin for a log-reading tool: ordering, time range, and permission context are left unaddressed.

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

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

Schema description coverage is 100%, with the 'n' parameter already documented as 'Сколько последних записей вернуть (по умолчанию 20)'. The description only echoes that same meaning ('Последние N записей'), adding no extra semantics such as a maximum value, so the baseline 3 applies.

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

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

The description names a specific resource ('журнал аудита вызовов' – API call audit log) and an operation ('Последние N записей' – return the last N records), so an agent knows exactly what it retrieves. It does not contrast itself with any sibling, but the audit-tail resource is clearly distinct from siblings like api_search, api_describe, or api_status.

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

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

There is no guidance on when to use this tool versus alternatives such as api_search or api_describe, and no stated exclusions or prerequisites. The word 'Последние' implies recency but the description never explains the trigger condition for 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 behavioral burden. It does not state whether this is a read-only/local operation, that no side effects occur, or how the tool name is resolved - a meaningful gap for a meta-tool that could mislead an agent into thinking it invokes the target tool.

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

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

A single compact sentence with no filler, front-loading the two outputs (schema and notes). It is efficient, though slightly terse given the meta nature of the tool.

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

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

For a one-parameter introspection tool with no annotations and no output schema, the description covers the minimum: what it returns and that it takes a name. It omits the crucial clarification that it describes a tool rather than executing it, which the sibling-heavy context makes necessary.

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

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

Schema coverage is 100% and the single 'tool' parameter is fully documented in the schema (name as in tools/list). The description adds only the requirement that the name match, which is baseline-level value given the schema already 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 the tool returns the full input schema and notes for a named tool, which is a recognizable meta/introspection purpose. However, it does not distinguish itself from the similar meta-tool api_search in the sibling list, leaving ambiguity about when introspection-by-name is preferred over search.

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 api_search or vs reading the parent tool's own schema directly. The 'по имени' phrase implies it requires a known tool name, but that constraint is not framed as a usage rule.

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 discloses the matching fields and the four returned fields (name, method, path, description), which is genuinely useful. It does not state auth requirements, result limits, or pagination for a search endpoint.

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

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

Two sentences with zero filler; the search behavior is front-loaded and the return shape follows immediately. Nothing is padded.

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

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

With no output schema, the description compensates by naming the returned fields, and the single parameter is fully documented. Only the absence of any routing relative to sibling discovery tools keeps it short of 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 coverage is 100%, so the baseline is 3, but the description adds real value by specifying that the query is matched against name, path, description and tag — information the schema's generic 'substring' wording does not convey.

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

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

States a specific verb and resource: searches Remnawave API tools by substring, and enumerates the searched fields (name, path, description, tag). An agent knows exactly what it does, though it never distinguishes itself from the similarly named sibling api_describe.

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

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

Usage is implied rather than stated — an agent can infer this is a discovery tool for locating other API endpoints, but the description gives no explicit when-to-use, when-not, or alternative (e.g. api_describe, api_status).

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

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

With no annotations, the description carries the full burden, and it does disclose useful traits: the base URL is returned 'without secrets' and the panel check reports 'only the response code' (GET /api/system/health). It still omits auth requirements and whether the health probe has a timeout or can fail the call, leaving meaningful gaps for an unannotated tool.

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

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

A single dense sentence with the key facts front-loaded and no filler. It is on the long side for a status tool, but every clause adds distinct 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 no output schema, the description appropriately enumerates the returned fields, which is exactly what an agent needs to interpret the response. Complexity is low, so little else is required; only the auth/prerequisite context 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 tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter-level detail is needed or missing.

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 resource (server status) and enumerates exactly what it reports: mode ro/rw, base URL, published tool count, spec version, and panel availability. It is clear and self-contained, but it never names or contrasts with nearby siblings like auth_get_status, system_get_remnawave_health, or system_get_metadata, so an agent gets no explicit routing help.

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

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

There is no statement of when to call this versus alternatives, nor any prerequisite (e.g., auth requirement). Usage is only inferable from the listed return fields, which is weak given several overlapping status/health siblings exist.

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

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

With no annotations, the description carries the full burden, and it does disclose an important behavioral trait: the admin-JWT-only auth requirement. It omits other behavior an agent needs — the confirm/preview gating, whether the secret is returned only once, and irreversibility — so it adds value but is incomplete.

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 purpose is front-loaded and the auth note is useful, but 'POST /api/tokens' duplicates the operation already conveyed by the name, and 'Tags: API Tokens Controller' is framework noise that earns no 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?

This is a mutation tool with no annotations and no output schema, so the description must carry the behavioral load. It covers auth but omits the confirm/preview semantics and, critically for a token tool, whether the generated token value is returned once and cannot be retrieved again.

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 ~50%, but the nested body properties (name, scopes, expiresInDays) and the confirm flag all carry their own schema descriptions, so the schema does most of the work. The description adds no parameter-level meaning, which is acceptable given the schema already documents the fields.

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

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

States a specific verb+resource: 'Create a new API token'. This clearly distinguishes it from the sibling read tools (api_tokens_get_api_tokens, api_tokens_get_scopes) and delete tool (api_tokens_delete_api_token). It does not explicitly name those siblings, so it stays just short of a 5.

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

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

It gives one meaningful precondition — the endpoint cannot be used with an API-key and requires an admin JWT — which is genuinely useful routing context. However, it never states when to create a token vs. using existing ones, and does not reference the sibling token tools as alternatives.

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

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

With no annotations, the description carries the full behavioral burden and does disclose the meaningful auth requirement (admin JWT only). It does not state that deletion is irreversible, what happens to the token's sessions, or the confirm/preview behavior, so the disclosure is partial.

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

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

It is short and front-loads the action and route, with the auth caveat following immediately. The trailing 'Tags: API Tokens Controller' line is controller metadata that does not earn its place, a minor blemish.

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, no-annotation, no-output-schema operation, the description covers the auth gate and the schema covers 'confirm', but it omits any warning about irreversibility or side effects. It is adequate but not complete for a delete operation.

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

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

Schema description coverage is 100%, so both 'uuid' and 'confirm' are already documented in the schema. The description adds no syntax or format detail beyond that, which is the expected baseline when the schema does the heavy lifting.

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

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

The description states a specific verb and resource ('Delete API token') plus the exact route 'DELETE /api/tokens/{uuid}', which unambiguously separates it from siblings like api_tokens_create_api_token and api_tokens_get_api_tokens. It does not explicitly name those siblings, but the action is specific and self-identifying.

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

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

It gives an important usage constraint: the endpoint is forbidden via API-key and requires an admin JWT-token. However, it offers no when-to-use vs when-not guidance relative to alternatives, and no prerequisites around the required 'confirm' preview step.

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 usefully discloses the authentication requirement (admin JWT only, API-key forbidden), which is real behavioral context. It does not describe the return shape, ordering, or whether secrets/token values are masked, leaving some gaps for a zero-param read endpoint.

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 useful content (verb, resource, auth constraint) is front-loaded, but the raw OpenAPI dump includes a redundant path line and a trailing 'Tags: API Tokens Controller' that adds no decision-relevant 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 simple zero-parameter read endpoint with no output schema, the key gotcha — the admin-only JWT auth requirement — is disclosed. Nothing critical is missing, though pagination/return details are absent.

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

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

The tool takes no parameters, so there is nothing to document and the baseline is 4. The description adds no parameter meaning, but none is needed.

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

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

States a specific verb (GET) and resource (all API tokens), so the agent knows exactly what it retrieves. It is distinguishable from siblings like api_tokens_create_api_token and api_tokens_delete_api_token by the 'Get all' phrasing, though it does not explicitly name those 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 gives a hard usage constraint — it cannot be used with an API-key and requires an admin JWT-token — which is genuine context for selecting/invoking the tool. However, it offers no guidance on when to prefer this over siblings such as api_tokens_get_scopes.

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

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

With no annotations, the description carries the full burden and does disclose a key behavioral trait: the endpoint is forbidden to API-key auth and requires an admin JWT. It also states the response is a catalog grouped by resource. It stops short of error semantics or rate limits, but the auth model is the critical disclosure here.

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 payload is short, but the leading 'GET /api/tokens/scopes' line merely restates the tool name and the trailing 'Tags: API Tokens Controller' is generator noise. The substantive sentence ('Returns the catalog of scopes...') is the only one that earns its place, and it sits third rather than first.

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

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

With no output schema, the description correctly describes the return (scope catalog grouped by resource) and the auth prerequisite. For a zero-parameter read tool this is close to complete, though error behavior for unauthorized callers is unaddressed.

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

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

The tool takes zero parameters, so the baseline is 4. Nothing in the description contradicts or misstates the schema.

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

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

States a specific verb+resource: retrieves the catalog of API token scopes, grouped by resource. This is clearly distinguishable from its siblings (create/delete/list tokens), which all operate on token instances rather than the scope catalog.

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

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

No explicit when-to-use guidance or named alternative, but the description implies its role (discovering what scopes a token can be granted) and supplies the operative access condition: 'Forbidden via "API-key", admin JWT only.' That condition is useful selection context even without a comparative statement.

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

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

No annotations are provided, so the description carries the full behavioral burden. The 'GET' verb hints at a read-only call, but the description never states whether authentication is required, what the status payload distinguishes (e.g., authenticated vs. anonymous vs. expired), or what happens on failure.

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

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

Extremely short and front-loaded, which is good, but roughly a third of the text is an HTTP route echo and a 'Tags:' artifact that add no decision-relevant information for an agent. It is terse rather than economical.

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

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

With no annotations, no output schema, and no parameter schema, the description is the only source of truth, and it omits what the status value means and any auth prerequisite. For an auth-status endpoint that an agent may use to decide whether to log in, this is a real gap.

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

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

The tool takes zero parameters, so the schema carries no semantics to document and the baseline is 4. Nothing in the description conflicts with the empty schema.

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

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

States a verb and resource ('Get the status of the authentication'), which is understandable, but it essentially restates the tool name and adds no differentiation from siblings such as auth_login, auth_register, or auth_passkey_authentication_verify. An agent cannot tell what 'authentication status' actually reports.

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 this endpoint should be called versus the other auth_* tools, nor any prerequisite (e.g., whether a session/token is required first). The Tag fragment 'Auth Controller' is generator metadata, not usage guidance.

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

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

No annotations are provided, so the description carries the full burden, yet it omits that this is a credential-submitting authentication call, what it returns (token/session?), and any security implications. The 'superadmin' scope is mentioned but its effect on returned privileges or permissions is not explained.

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?

Extremely short but that shortness is under-specification rather than concision. The route line and 'Tags: Auth Controller' are boilerplate that consume the entire description without earning their 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?

No annotations, no output schema, nested required body, and a confirm-preview mechanism that is crucial to correct invocation. The description says nothing about the confirm flow or the login result, leaving a login tool materially under-documented.

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 only 50%: the nested body's username/password are documented in the schema, but the top-level 'confirm' parameter's preview/confirmation behavior is invisible in the description. For a login tool, the description should at least say credentials go in the body; it does not compensate for the gap.

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

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

States a verb+resource ('Login as superadmin') but is generic boilerplate generated from an OpenAPI route; it does not distinguish itself from sibling auth tools like auth_register or auth_passkey_authentication_verify beyond the superadmin note. The route path adds little for an agent choosing between auth tools.

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

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

No indication of when to prefer this login over other auth paths (auth_oauth2_authorize, auth_passkey_authentication_options/verify, auth_register), nor prerequisites. The significance of 'superadmin' login is left unexplained.

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 but adds essentially nothing beyond the HTTP route and tag. It does not mention that this likely returns an authorization URL/redirect, what permissions or state are required, or any side effects; the only behavioral hint (the confirm preview mechanism) lives in the schema, not the description.

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 text is short and front-loaded with the route, but it is essentially boilerplate ('POST /api/auth/oauth2/authorize', 'Tags: Auth Controller') that conveys little semantic value. It is concise without being wasteful, yet barely any sentence earns its place as guidance.

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 stateful OAuth2 initiation endpoint with a nested body and no output schema, the description omits what the call returns (e.g., a redirect/auth URL), how it interacts with the callback tool, and what the provider choice implies. It is too thin to let an agent call it correctly with confidence.

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

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

Schema coverage is 50% and the description explains neither the provider enum values nor the nested body structure. The only documented parameter (confirm) is described in the schema itself, so the description adds no meaning beyond structured fields.

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 recognizable verb+resource ('Initiate OAuth2 authorization') and exposes the HTTP route, so the general purpose is understandable. However, it does not distinguish this from close siblings such as auth_oauth2_callback or auth_login, and the 'Initiate' step is not explained beyond the route line.

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 auth_login, auth_register, or auth_oauth2_callback, and no prerequisites or context are given. An agent must infer the place of this endpoint in the OAuth2 flow entirely on its own.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no statement about side effects (session/token issuance), state validation, idempotency, or auth requirements. Only the bare POST method hints at mutation.

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

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

It is very short and front-loads the method/path, but the 'Tags: Auth Controller' line is generator noise that adds no value. Efficiency comes from omission rather than deliberate editing.

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

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

For an OAuth2 callback with a nested required body, no output schema, and no annotations, the description leaves critical questions unanswered (what it returns, whether it establishes a session, what state is validated). It is not sufficient to call the tool correctly.

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

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

Schema coverage is only 50%: the confirm flag is documented in the schema, but code, state, and provider in the nested body object are undocumented. The description adds no parameter meaning whatsoever, so it fails to compensate for the coverage gap on a nested request body.

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 reads 'POST /api/auth/oauth2/callback' plus 'Callback from OAuth2', which essentially restates the tool name rather than explaining what the endpoint does (e.g. exchanges the OAuth2 code for a session/token). It gives the HTTP method and path, but no functional verb that distinguishes it from the sibling auth_oauth2_authorize.

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

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

There is no guidance on when to call this versus auth_oauth2_authorize or auth_login, no mention that it is the redirect target of the OAuth2 flow, and no exclusions. An agent must infer usage entirely from the endpoint name.

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

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

No annotations are provided, so the description carries the full burden. It says nothing about whether this requires an existing session, returns a challenge, or is a read-only step in a multi-step flow; for an auth endpoint with zero annotation coverage this is a meaningful gap in behavioral 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?

The meaningful sentence is front-loaded, but the description is cluttered with the raw route string and a 'Tags:' line that add no value to an agent. It's short but not 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?

For an authentication endpoint with no annotations and no output schema, an agent would need to know this returns a challenge/options payload and that it precedes verify. None of that flow context is provided, so the definition is not complete enough for reliable 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?

There are zero parameters, so the schema fully covers the input surface and the baseline is 4. The description adds nothing further needed, and none is required.

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

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

States a specific verb (Get) and resource (authentication options for passkey), and the HTTP path/verb anchors it to a concrete endpoint. It's slightly obscured by the raw route and 'Tags: Auth Controller' boilerplate, but the resource is identifiable and distinct from siblings like auth_passkey_authentication_verify.

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

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

No guidance on when to use this versus auth_passkey_authentication_verify or auth_login. The passkey flow context (this is the first step before verify) is left entirely to inference, so an agent has no explicit routing signal.

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 nothing about side effects, session/token issuance on success, failure behavior, or authentication requirements beyond the word 'Verify'. The only behavioral hint (the 'confirm' parameter's non-GET preview behavior) comes from the schema, not the description.

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 text is short but padded with non-earning content: the HTTP method/path echo and 'Tags: Auth Controller' are mechanical filler that do not help an agent invoke the tool. What little remains is not front-loaded with the operationally useful information.

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

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

For a two-step passkey authentication flow with a nested WebAuthn response object, no output schema, and no annotations, the description leaves the agent without enough context to call it correctly. It neither explains the expected credential/response shape nor the sequence relative to its siblings.

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 only 50% and the critical nested 'body'/'response' parameter is entirely undocumented (no type or description) in both schema and text. The description adds zero parameter meaning, so it fails to compensate for the coverage gap.

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

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

The description states a recognizable verb and resource ('Verify the authentication for passkey'), so an agent can tell roughly what it does. However, it does not differentiate from closely-related siblings such as auth_passkey_authentication_options or passkey_passkey_registration_verify, and the leading 'POST /api/auth/passkey/authentication/verify' line is mechanical path echo rather than added meaning.

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

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

There is no indication of when this tool should be invoked versus the options-generation or registration siblings, nor any stated precondition (e.g., that it must follow a prior authentication-options call). Usage is only weakly implied by the verb 'Verify'.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose that this creates a superadmin-level account (a privileged mutation), whether it requires prior authentication, rate limits, or that the confirm parameter must be set to actually execute rather than preview. The 'superadmin' hint is the only behavioral signal.

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

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

The text is short but poorly structured: it front-loads a raw HTTP endpoint and a controller tag, both of which are low-value for an agent choosing a tool. Only 'Register as superadmin' carries real meaning, and the rest is filler that does not help the agent decide or invoke correctly.

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 privileged mutation tool with nested body parameters, a non-obvious confirm gate, and no annotations or output schema. The description fails to explain the superadmin creation implications, the confirm preview behavior (critical for correct invocation), or any auth/permission requirements. It is inadequate for the tool's complexity.

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

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

Schema coverage is 50%; the schema documents username and confirm (with a detailed Russian description of the preview/confirm mechanism), but the password field only has a regex pattern, not a description. The description adds nothing about parameters, so it does not compensate for the coverage gap. Baseline 3 is appropriate given half the parameters are self-documenting in the schema.

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

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

The description states a specific verb and resource ('Register as superadmin') plus the HTTP endpoint POST /api/auth/register. This clearly distinguishes it from sibling auth tools like auth_login and auth_oauth2_authorize, though the raw HTTP line and 'Tags: Auth Controller' add noise rather than clarity.

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 registration context but provides no explicit when-to-use or when-not-to-use guidance versus alternatives like auth_login or auth_get_status. The 'Register as superadmin' phrasing hints at a privileged operation, but there is no stated prerequisite or condition.

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 data-freshness behavior ('usage data is flushed to the database roughly every 2 minutes') and the threshold semantics, but it never clarifies that this POST is effectively a read operation, nor mentions auth or rate-limit 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 core sentence is front-loaded and useful, but the definition includes raw HTTP method/path, a 'Tags:' line, and a stray Russian pagination line that do not earn their place. Size is acceptable but structure is noisy.

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 5 parameters (nested body object), the description covers purpose and data freshness but omits usage guidance, response shape, and correctly-specified pagination. It is adequate to attempt a call but leaves meaningful gaps.

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

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

Schema coverage is 80%, so the baseline is 3, but the description actively introduces confusion: it says 'Пагинация через query-параметры: start', yet the schema defines 'start' as a date bound, not a pagination cursor, and there is no other pagination parameter. This contradiction with the schema undermines rather than clarifies parameter meaning.

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

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

The description gives a specific verb and resource: 'Get users exceeding a traffic threshold on the given nodes for a period', and clarifies the exact predicate ('total usage ... >= minTotalBytes'). This is much clearer than a bare endpoint, but it does not distinguish itself from close siblings like bandwidth_stats_nodes_get_stats_node_users_usage or bandwidth_stats_users_get_stats_nodes_usage.

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

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

There is no when-to-use guidance and no alternative named, despite several near-identical bandwidth-stats siblings. The trailing Russian line about pagination does not tell the agent when this tool is the right choice, so usage context is essentially 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 full behavioral burden. It reveals the HTTP verb and path (POST) and a pagination note about 'start', but never explains the confirmation/preview behavior of this non-GET operation, rate limits, or auth needs. The safety-relevant behavior is hidden in the schema, not the description.

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

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

It is short, but front-loaded with an HTTP method/path and a 'Tags:' dump rather than the tool's purpose. The trailing Russian pagination sentence is oddly placed and low-value, so structure is poor even though word count is low.

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 5-parameter, nested-body POST tool with no annotations and no output schema, the description is inadequate. It omits the confirm requirement, the body structure (nodesUuids), date-range semantics, and return shape, leaving the agent under-informed.

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 only 60% and topUsersLimit has no description anywhere. The description only mentions pagination via 'start', which actually conflicts with the schema's date-typed start parameter, adding confusion rather than clarity for end, confirm, and topUsersLimit.

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 line 'Get Nodes Users Usage by Nodes UUIDs' largely restates the tool name and offers no specificity beyond 'by Nodes UUIDs'. It is nearly indistinguishable from siblings like bandwidth_stats_nodes_get_node_usage and bandwidth_stats_nodes_get_stats_node_users_usage, and an agent cannot tell which stat this returns.

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 the many near-identical bandwidth-stats siblings. No prerequisites, no mention of the required confirm flag, nothing that would route an agent correctly.

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

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

No annotations are provided, so the description carries the full burden. It discloses only the HTTP method/path and a controller tag, saying nothing about auth requirements, rate limits, result size, or the meaning of the returned data. Worse, the pagination claim ('Пагинация через query-параметры: start') is likely inaccurate since 'start' is a required date bound, so the one behavioral hint it gives may mislead.

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 text is short and front-loads the core operation, but it spends half its length on low-value boilerplate (raw route, 'Tags: Bandwidth Stats Controller') and includes the misleading pagination sentence instead of useful information.

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

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

With 4 parameters (3 required), no annotations, and no output schema, the description is the only source of behavioral context and it is insufficient: it never explains what usage dimensions are returned, how the date range is applied, or what topUsersLimit controls.

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 only 50%: 'start', 'end', and 'uuid' are documented in the schema, but 'topUsersLimit' (default 100, minimum 1) is undocumented anywhere. The description adds no clarifying meaning for any parameter and actively mislabels 'start' as a pagination parameter rather than a date range bound.

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 verb and resource ('Get Node Users Usage by Node UUID'), but it is largely a restatement of the tool name and raw HTTP path. It does not explain what 'users usage' actually returns (per-user traffic? per-user connection counts?) nor differentiate it from the near-identical siblings bandwidth_stats_nodes_get_node_usage and bandwidth_stats_nodes_get_stats_nodes_users_usage.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of alternatives despite three closely-named sibling bandwidth-stats tools. The only usage note is the Russian sentence claiming pagination via 'start', which is not an exclusion or selection criterion.

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

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

With no annotations, the description carries the full behavioral burden, and it delivers little. The GET route implies a read operation, and the trailing note hints at pagination, but there is no disclosure of auth requirements, rate limits, whether the range is inclusive, or what happens for out-of-range dates. Worse, the pagination note is attached to 'start', which the schema defines as a required start date, so the behavioral hint is likely wrong.

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 text is short but poorly front-loaded for an agent: it leads with a raw HTTP route, then a purpose line, then a tag list, then a Russian pagination fragment. The tag line and the pagination fragment do not earn their place and the fragment is confusing rather than 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 4-parameter tool with no annotations and no output schema, the description is not complete enough. It never explains the topNodesLimit parameter, never clarifies the range semantics, and its one parameter reference is misleading. The only compensating detail is the route, which at least confirms this is a per-user read endpoint.

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

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

Schema description coverage is 75% (end, start, userId documented; topNodesLimit has no description). The description only mentions 'start', and does so in a misleading way, framing it as a pagination query parameter when it is actually a required date bound. It adds no correct meaning beyond the schema and omits the undocumented topNodesLimit entirely.

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 line 'Get User Usage by Range' gives a specific verb+resource, and the route '/api/bandwidth-stats/users/{userId}' confirms the scope is per-user bandwidth usage over a date range. However, the tool name mentions 'stats_nodes_usage' while the description says user usage, creating ambiguity, and nothing distinguishes it from siblings like bandwidth_stats_nodes_get_stats_node_users_usage or internal_squad_stats_get_internal_squad_user_usage. The 'Tags: Bandwidth Stats Controller' line is noise that does not clarify purpose.

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

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

There is no statement of when to use this tool versus the many similarly-named bandwidth-stats siblings. The only usage-flavored sentence is the Russian note about pagination via query parameters, which does not tell the agent when this tool is the right choice. The agent must infer selection purely from the route and name.

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

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

No annotations are provided, so the description carries the full behavioral burden. The only signal is the raw 'POST /api/config-profiles' path, which implies a mutation, but the description never states that creation is persistent, whether it requires auth, or what the confirm-preview flow (documented only in the schema) actually does.

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 text is short but a large fraction is noise: the raw 'POST /api/config-profiles' line and the 'Tags: Config Profiles Controller' line add nothing an agent can act on. Only 'Create config profile' is substantive.

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, no output schema, a nested required body, and a non-obvious confirm/preview mechanism, the description is far too thin. It omits return behavior, permission needs, and the confirmation workflow that the agent must understand to call 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 description coverage is 50% and the description adds no parameter meaning at all. It does not explain the required body (name/config), the name pattern/length constraints, or the confirm-preview semantics, leaving the nested-object payload largely undocumented in prose.

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

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

The description states a clear verb+resource combination ('Create config profile'), which is enough to distinguish it from the sibling read/update/delete config-profile tools. It does not, however, differentiate itself explicitly from those siblings or explain the scope of what is created.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as update_config_profile or reorder_config_profiles. The agent gets the operation name but nothing about context or conditions for invoking 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 behavioral burden, yet it discloses nothing beyond the HTTP verb. For a destructive DELETE it omits whether the operation is reversible, what dependent resources are affected, permission requirements, and the fact that the schema's 'confirm' flag gates execution (without it only a preview 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 short and front-loaded, but the 'DELETE /api/config-profiles/{uuid}' line largely duplicates the tool name and the 'Tags: Config Profiles Controller' line is auto-generated filler that contributes no selection 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 destructive operation with no annotations and no output schema, the description is too thin. Most critically, it never mentions the confirm/preview behavior defined in the schema, which materially changes how an agent must invoke the 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%, so both the uuid and the confirm parameters are already documented in the schema. The description adds no additional meaning about either parameter, which is acceptable given the high coverage, 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 verb and resource ('Delete config profile') plus the raw REST endpoint, so the basic action is understandable. However, it is essentially a restatement of the tool name and adds no differentiation from siblings like config_profile_update_config_profile or config_profile_get_config_profile_by_uuid.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. An agent gets no signal about when deletion is appropriate versus updating or retrieving the profile, nor any warning about 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses essentially nothing: no pagination behavior, no auth/permission requirements, no indication of how results are grouped by profile, and no volume expectations for an endpoint that fans out across all profiles. The only behavioral hint is the 'GET' verb embedded in the raw route string.

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 core sentence is short and front-loaded, which is good, but the raw 'GET /api/config-profiles/inbounds' line restates the tool name as a route, and the 'Tags: Config Profiles Controller' line is generator boilerplate that adds no decision-relevant information to an agent.

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

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

For a zero-parameter read endpoint this is minimally adequate, but with no output schema and no annotations the description should at least describe the shape or grouping of the returned inbounds (e.g., whether they are flat or keyed by config profile). It is complete enough to call, not complete enough to predict the response.

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

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

The tool takes zero parameters, so there is no parameter semantics to document and the baseline of 4 applies. Nothing in the description is needed to call it correctly with respect to arguments.

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

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

The description gives a clear verb+resource ('Get all inbounds') and a scope qualifier ('from all config profiles') that implicitly separates it from the per-profile sibling config_profile_get_inbounds_by_profile_uuid. It does not name that sibling, so the differentiation is inferred rather than explicit.

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

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

The 'from all config profiles' scope implies this is the aggregate variant to use when you want every profile's inbounds rather than one profile's, which is usable guidance. However, it never names the alternative tool or states when NOT to use this one, leaving the routing 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, and the description adds almost nothing beyond the HTTP method 'GET', which weakly implies a read-only operation. It does not explain what 'computed' means, whether the result is derived/rendered at request time, auth requirements, or whether any caching or rate limits apply.

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?

Short, but the raw 'GET /api/...' line and the 'Get computed config profile by uuid' sentence are redundant restatements of the same fact, and the 'Tags: Config Profiles Controller' trailer is internal noise rather than agent-facing guidance.

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 one parameter, no annotations, and no output schema, the description is the only source of context, yet it omits any description of the returned computed configuration or error behavior. It is barely sufficient for an agent to call the tool blindly by uuid.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It only shows uuid as a path segment; the uuid regex pattern and format live entirely in the schema. No explanation of what the uuid identifies or what happens if it is unknown.

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

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

The description states a specific verb and resource ('Get computed config profile by uuid') and the HTTP route confirms the operation. It is clear what the tool does, but it never contrasts itself with the closely named sibling config_profile_get_config_profile_by_uuid, so an agent must infer the 'computed' distinction on its own.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives, even though config_profile_get_config_profile_by_uuid is an obvious neighboring read tool. Usage is only implied by the endpoint name.

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

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

No annotations are provided, so the description carries full behavioral burden, and it discloses almost nothing: no auth requirements, no error behavior for unknown UUIDs, no note that this is a read-only operation. It is a bare restatement of the route.

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?

Very short and front-loaded, but the content is essentially redundant: the route line, the sentence, and the 'Tags' footer repeat each other. Concise but not economical.

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

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

For a read tool with no annotations and no output schema, the description should at least hint at what a config profile contains or what errors are possible. None of that is present, leaving the agent with only the route.

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?

Only one parameter (uuid) with 0% schema description coverage. The name 'uuid' and its format/pattern make the meaning self-evident, so the description's '{uuid}' route placeholder adds nothing but the parameter is also hard to misinterpret. Baseline for a trivial single-param 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 verb+resource ('Get config profile by uuid'), and the HTTP method/route line reinforces it, but it is a near-tautology of the tool name and offers no differentiation from siblings like config_profile_get_computed_config_profile_by_uuid or config_profile_get_config_profiles.

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

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

No when-to-use guidance, no mention of alternatives, and no indication of when the plain profile is preferable to the computed variant or the list endpoint. The agent must infer all routing decisions.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses essentially nothing beyond the HTTP method — no auth requirements, no pagination, no volume or ordering characteristics of the returned profile list. The URL string is the only concrete behavioral hint.

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

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

It is very short, which is good, but the second half is auto-generated boilerplate ('Tags: Config Profiles Controller') that conveys no information to an agent. The one useful line is front-loaded, so structure is acceptable but padded.

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, no annotations, and no parameters, the description is the only source of information, and it omits anything an agent would need — return shape, whether the list is filtered or paginated, and how it relates to the by-uuid and tags variants. It is not adequate for a listing endpoint in this dense tool family.

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

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

The tool takes zero parameters, so per the baseline there is no parameter semantics to explain and nothing for the description to compensate for. The empty schema is unambiguous.

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 ('Get config profiles'), so the basic purpose is legible. However, it does nothing to distinguish itself from closely named siblings such as config_profile_get_config_profile_by_uuid, config_profile_get_tags, or config_profile_get_computed_config_profile_by_uuid — an agent cannot tell from the text why it would pick this list endpoint over those.

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

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

There is no when-to-use guidance, no statement of what the returned set represents, and no mention of alternatives among the large config_profile sibling group. The HTTP verb 'GET' is the only implicit usage signal.

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

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

With no annotations present, the description carries the full behavioral burden, yet it only reveals that this is a GET (implying a safe read). It says nothing about authentication/scope requirements, whether results are paginated or cached, or what the payload contains.

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 operation is stated in one short line, which is efficient, but the trailing 'Tags: Config Profiles Controller' is backend grouping metadata that adds no decision value for an agent. Front-loading is fine; one of the three lines does not earn 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?

With no annotations, no output schema, and no clarification of what an 'inbound' is in this domain, the definition is thin for an agent that must decide whether to call it and how to interpret results. Only the required input is reasonably covered.

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 fully documented in the schema with a format and pattern. The description adds only the phrase 'profile uuid', which matches the schema and contributes no extra meaning, so the baseline 3 applies.

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

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

The description states a clear verb+resource ('Get inbounds') scoped by an identifier ('by profile uuid'), and the raw route GET /api/config-profiles/{uuid}/inbounds reinforces it. It does not, however, distinguish this from sibling config_profile_get_all_inbounds or explain how the two differ.

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

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

There is no when-to-use guidance and no mention of alternatives such as config_profile_get_all_inbounds or config_profile_get_computed_config_profile_by_uuid. The agent must infer the selection criteria 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. The 'GET' prefix and 'Get' verb do convey that this is a read operation, but nothing is said about what the tags represent, whether the list can be empty, or the response shape. For a zero-annotation tool this is thin.

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

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

The description is short and front-loaded, but the raw 'GET /api/config-profiles/tags' line duplicates the following sentence and the 'Tags: Config Profiles Controller' line is autogenerated metadata of little value to an agent.

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

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

For a simple no-param read with no output schema, the description states what is returned at a high level, but it does not describe the return format (e.g. list of tag strings) that an agent would otherwise get from an 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 tool takes no parameters, so per the rubric the baseline is 4. There is nothing for the description to clarify beyond what the empty schema already conveys.

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 (tags of Config Profiles), so an agent can distinguish it from set_tags, get_config_profiles, and other *_get_tags siblings by the 'Config Profiles' scope. It is clear but offers no explicit sibling differentiation beyond the resource 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?

No guidance on when to use this versus config_profile_set_tags or the many other tag-fetching endpoints. There are no prerequisites, exclusions, or named alternatives, leaving usage entirely 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. It says 'reorder' (implying a mutation of ordering state) but does not disclose whether items must be exhaustive, whether partial lists are allowed, whether viewPosition values must be unique/contiguous, or that reordering affects downstream config resolution. The confirm/dry-run behavior is only documented in the schema, not here.

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?

Very short, but front-loads the raw endpoint and a 'Tags: Config Profiles Controller' line that consume space without helping selection. The actual purpose sentence is buried behind protocol noise.

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

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

A nested-object mutation with no annotations and no output schema requires more disclosure: ordering semantics, required payload shape, and effect on existing profile order are all missing. The confirm semantics are only in the schema, leaving the description inadequate for correct invocation.

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

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

Schema description coverage is 50%: the nested body.items[].uuid and viewPosition have no descriptions at all, and the description adds no meaning beyond their types. Only the confirm parameter is documented, and that documentation lives in the schema rather than the description, so nothing is compensated for the undocumented half.

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: 'Reorder config profiles'. Clear enough for an agent to understand the operation, but it offers no differentiation from the many sibling reorder tools (nodes_reorder_nodes, hosts_reorder_hosts, internal_squad_reorder_internal_squads, etc.). The HTTP method/path prefix adds nothing to purpose.

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

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

No guidance on when to use this versus config_profile_update_config_profile or the other reorder tools. No prerequisites, no mention of whether the payload must contain the full ordered set of profiles. The agent must infer everything.

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 absent, so the description carries the full burden. It does not disclose that this is a mutation that presumably replaces the existing tag set, nor mention permissions, idempotency, or the confirm/preview behavior which is only captured in the schema's Russian confirm field.

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 definition is short and front-loads the operation, but it includes low-value noise: the raw 'PATCH /api/config-profiles/tags' path and the 'Tags: Config Profiles Controller' controller label, which don't help an agent invoke the tool correctly.

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 under-specified. It omits whether tags are replaced or merged, what a successful response contains, and any error/confirmation expectations beyond the schema field.

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 50%; the confirm parameter is documented in the schema itself (including its preview semantics), and the nested body structure is typed. The description adds no meaning beyond the structured fields, so the baseline 3 applies.

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

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

The description states a specific verb+resource ('Set tags of Config Profile'), which is clearer than a bare name restatement. However, it does not differentiate itself from the sibling config_profile_get_tags or explain 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?

No when-to-use guidance is provided. It does not say when to call this versus reading tags, nor any prerequisites such as requiring the profile to exist or a prior lookup.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies mutation via PATCH but says nothing about permissions, reversibility, partial-merge vs replace semantics of a PATCH, or how the nested config object is treated. The only behavioral hint (preview-without-confirm) lives in the schema's confirm field, not the description, so structured data is doing all the work here.

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?

Short, but two of the three lines are low-value metadata: a raw REST path ("PATCH /api/config-profiles") and "Tags: Config Profiles Controller". The one useful sentence is buried in the middle rather than 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 mutation tool with no annotations, no output schema, a nested body object, and only 50% parameter coverage, the description is far too thin. It omits the required uuid, the meaning of the nested config payload, and any notion of return or failure 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 description coverage is 50%, with the confirm parameter fully documented in the schema and the body (name, uuid, config) left undocumented. The description adds no parameter meaning beyond the schema — it does not clarify what goes in "config" or how it merges, so it fails to compensate for the coverage gap.

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

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

"Update Core Config in specific config profile" gives a recognizable verb (update) and resource (config profile), so the general purpose is inferable. However, "Core Config" is undefined jargon, and the description does nothing to distinguish this from siblings like config_profile_set_tags, config_profile_reorder_config_profiles, or subscription_page_config_update_config.

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

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

There is no indication of when to use this tool versus alternatives, no prerequisites (e.g., a valid existing profile uuid), and no mention of what happens on success. An agent must guess 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. It only reveals the HTTP verb (POST) and route; it says nothing about permissions, rate limits, side effects, or that the operation may be asynchronous with results fetched via a separate `_result` tool. The confirm/preview semantics live in the schema, not the description, so the description adds little 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 short and front-loads the HTTP route, but it also carries boilerplate that does not earn its place ('Tags: Connections Controller') and a raw path/verb that adds little decision value. It is brief without being high-signal.

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 request-initiating tool with no annotations and no output schema, yet the description does not explain what a 'connection' is, what the call returns (e.g. a job or identifier), or how it relates to the `_result` sibling. For a tool with this complexity and no structured support, the description is under-specified.

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

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

Schema description coverage is 100%, with `nodeUuid` documented as a UUID and `confirm` documented in detail (including the preview/no-send behavior). The description adds no parameter meaning beyond the schema, which is the expected baseline when the schema fully documents both 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 names a verb-plus-resource pair ('Request Connections for Node') and exposes the underlying route, so an agent can tell roughly what it does. However, it reads as an auto-generated HTTP stub and gives no signal that distinguishes it from the very similar sibling `connections_connections_by_node_result`, which likely returns the outcome of this same request. Purpose is stated but not 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 when-to-use, when-not-to-use, or alternative-routing guidance anywhere in the description. Nothing tells the agent that this issues a request while `connections_connections_by_node_result` presumably retrieves the resulting data, nor what conditions make this the right call. Guidance is effectively 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?

With no annotations, the description carries the full behavioral burden, and it discloses almost nothing: not whether the job must be complete before calling, not what happens if the jobId is unknown or the job is still running, not the return shape, and not any auth or rate-limit context. Only the jobId parameter name hints at asynchronous 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 text is short and front-loads the verb and resource, but a raw HTTP route ("/api/connections/by-node/{jobId}") and the "Tags: Connections Controller" line are noise that consumes most of the description without helping an agent.

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

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

For a job-result retrieval endpoint with no annotations, no output schema, and an undocumented required parameter, the description should explain the async workflow and what the result contains. Instead it repeats the route, leaving the agent without enough to invoke it confidently or interpret its output.

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

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

Schema description coverage is 0% for the single jobId parameter, and the description adds no meaning beyond echoing the parameter name ("by Job ID"). It does not say where the jobId comes from, whether it is a UUID, or how long it remains valid, so the schema gap is left unfilled.

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 verb and resource ("Get Connections for Node by Job ID") and the required jobId implies result retrieval, but the text is essentially a restatement of the raw HTTP route with controller/tag boilerplate. It does not differentiate this result-fetching tool from the sibling connections_connections_by_node that presumably launches the job, so an agent must infer the pairing from the name alone.

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

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

There is no guidance on when to call this versus connections_connections_by_node or connections_connections_by_user_result. The async job workflow (start with the sibling, then poll this with the returned jobId) is never stated, and there are no prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only discloses the HTTP verb and path. It does not explain the non-GET 'confirm' preview flow, whether this is a read despite being a POST, or any authorization requirement.

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 text is short but is a raw metadata dump (method, path, 'Tags: Connections Controller') rather than a useful sentence. It is under-specified rather than concise, and the tag line is noise.

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

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

For a tool with no annotations, an undocumented required parameter, and no output schema, the description leaves everything an agent needs unanswered: return shape, why a POST reads data, and the confirm behavior. It is effectively incomplete.

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 only 50%: userId has no description, and while the path template hints userId is a route parameter, the description says nothing about it. It also ignores the confirm parameter, whose preview semantics (documented only in the schema) are central to correct invocation.

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

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

The phrase 'Request Connections for User' essentially restates the tool name 'connections_connections_by_user' and adds nothing about what 'connections' means (active sessions, IPs, etc.). It provides no differentiation from the sibling connections_connections_by_user_result, so an agent cannot tell them apart from the text alone.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the closely related siblings (connections_connections_by_user_result, connections_connections_by_node). The description is raw endpoint metadata with zero routing help.

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 at all, the description carries the full behavioral burden, and it discloses almost nothing. An agent cannot tell whether the job must be complete, what happens for an unknown/expired jobId, whether this requires auth, or whether results are transient.

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 body is short and front-loads the endpoint, but it wastes lines on a raw HTTP route and a 'Tags: Connections Controller' artifact that give the agent no actionable information.

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

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

For a tool that appears to be the result-fetch half of a job pair, with no output schema, no annotations, and an undocumented parameter, the description is under-specified. It omits the job lifecycle, return shape, and error behavior an agent needs to invoke it correctly.

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

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

Schema description coverage is 0%, so the description would need to compensate for the single required parameter. It only echoes jobId as a path placeholder ({jobId}); it never explains what a job ID is, its format, or where the agent obtains one.

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 verb (Get) and resource (Connections for User) and exposes the endpoint path, so the literal purpose is discernible. However, it never distincts itself from the sibling 'connections_connections_by_user' – the 'result' suffix and jobId parameter strongly imply it retrieves the output of an async job, but that is left for the agent to infer.

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

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

There is no statement of when to call this versus connections_connections_by_user or connections_connections_by_node_result, nor any prerequisite (e.g. that a job must first be started). Usage is only implied by the name.

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

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

No annotations are supplied, so the description carries the full behavioral burden, yet it discloses nothing about permissions, irreversibility, or the confirm-gate that determines whether the request is actually sent. "Drop" implies a mutating, destructive action, but the description never confirms or qualifies that.

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

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

It is short and front-loaded, but the leading HTTP route and trailing "Tags: Connections Controller" are boilerplate that costs space without adding agent-relevant meaning. The one substantive sentence is buried under that noise.

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 two-parameter tool with no annotations and no output schema, the description should cover what happens on execution and the confirm behavior. Instead the confirm semantics live only in a Russian-language schema description, and the tool description explains nothing about outcomes or auth.

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 50%, and the nested union members (dropBy, targetNodes) already carry their own descriptions, so the schema does much of the work. The description's "for Users or IPs" loosely maps to the dropBy union but adds no syntax, defaults, or clarity about the confirm 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 line "Drop Connections for Users or IPs" gives a verb and resource, but "drop" is never explained (terminate active sessions vs. remove records) and the definition is padded with a raw REST route and tag metadata. It does not distinguish this tool from the read-only connections siblings (connections_by_user, connections_by_node).

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

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

There is no statement of when to use this tool versus alternatives, no prerequisites, and no mention that a confirmation flag exists. The only hint of scope is the phrase "for Users or IPs," which implies targeting but gives no usage guidance.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose the key trait: this is an async operation that returns a job ID rather than a result, plus the up-to-a-minute latency. However, it omits that this is a POST mutation, that the confirm parameter gates actual execution (preview otherwise), and any auth requirements.

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

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

The operative content is two tight sentences, but the raw endpoint line 'POST /api/connections/geocheck/{nodeUuid}' and the 'Tags: Connections Controller' trailer are generated filler that pushes the real purpose behind noise instead of front-loading it.

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

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

For an async, no-output-schema tool, the description covers the critical gotcha (returns a job ID, must poll a sibling, up to a minute delay). It lacks detail on what a geocheck actually does and the confirm-preview behavior, but the information an agent needs to call it correctly is essentially present.

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 67%, so most parameters are already documented in the schema (nodeUuid, body.ip, body.interface, and the confirm flag with a detailed Russian-language explanation). The description adds only the implied role of nodeUuid via the URL template and no meaning for the body fields, so it neither compensates for nor extends the schema.

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

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

States a specific verb and resource ('Queues a geocheck on the node') and explicitly frames the tool as the queueing half of an async pair, naming the sibling result tool 'Get Geocheck for Node by Job ID'. An agent can tell it apart from connections_geocheck_by_node_result without opening either 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?

Explicitly routes the agent to the follow-up tool for the result and gives a timing expectation ('the node may take up to a minute to answer'), which is exactly the when-to-use context for an async job tool. It stops short of stating when-not to use it or any 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 exist, so the description carries the full burden. The 'GET' prefix hints at a read-only operation, but nothing is said about whether the job may still be running, whether polling is required, or what errors occur for an unknown jobId.

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?

Very short, but the body is just the raw HTTP path plus a restated title, and the trailing 'Tags: Connections Controller' line is generator noise that consumes space without informing an agent.

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

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

For a job-result retrieval tool with no output schema and no annotations, the description should at least sketch the returned geocheck payload or the job lifecycle; instead it leaves the agent with only an endpoint path.

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

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

Schema description coverage is 0% for the single required jobId parameter. The description only repeats the term 'Job ID' (already in the name), adding no format details, sourcing guidance, or distinction between job identifiers of different endpoint families.

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 phrasing 'Get Geocheck for Node by Job ID' names a verb and resource, but it largely restates the tool name and does not distinguish this result-fetching endpoint from its sibling connections_geocheck_by_node, with which an agent could easily confuse it.

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

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

No when-to-use guidance is given: it doesn't say this retrieves the outcome of a previously-started geocheck job, nor when to prefer connections_geocheck_by_node or connections_connections_by_node_result instead.

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

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

No annotations are provided, so the description carries the full burden. It reveals only that this is a POST bulk mutation via the raw HTTP line; it omits that the operation requires confirm:true (documented only in the schema), what the bulk action affects, whether it is reversible, 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?

It is short, but the content is largely raw scaffolding: the HTTP verb/path line and a 'Tags:' controller label are generated noise rather than useful front-loaded information. The one meaningful sentence is buried after the route string.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin: it neither repeats the confirm/preview behavior nor explains the effect on the target squad. It lacks the safety and scope context an agent needs before invoking a bulk write.

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 uuid and confirm parameters are already fully documented in the schema, and the description adds nothing beyond the path it repeats. Baseline 3 applies when the schema does the semantic work.

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

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

The description states a verb and resource ('Add all users to external squad'), which is clearer than a bare endpoint dump and does distinguish the external-squad family from internal-squad siblings by name. However, 'add all users' is ambiguous and arguably inconsistent with the tool name, which implies adding specific users; no user list exists in the schema, leaving it unclear what is actually being added.

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

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

There is no guidance on when to use this versus external_squad_remove_users_from_external_squad or the internal-squad add tools, nor any prerequisites, idempotency notes, or mention of the required confirm flag. The only routing signal is the endpoint path.

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

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

No annotations are supplied, so the description carries the full disclosure burden, yet it only restates the route and name. It does not say what a squad is, what permissions are required, whether the call is idempotent, or how duplicates are handled. The dry-run/confirm behavior appears only in the schema, not the description.

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 text is short and front-loaded with the route and action, which is efficient, but the 'Tags: External Squads Controller' line is framework noise that consumes part of an already thin description.

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 a nested required body, no annotations, and no output schema, this description is under-specified. An agent gets the endpoint but nothing about required permissions, side effects, or the confirm-preview workflow that governs whether the request is actually sent.

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 50% and the description adds no parameter meaning at all. It does not explain the nested body shape, the name constraint (2-30 chars, allowed character pattern), or the confirm flag, leaving the nested-object semantics to the schema alone.

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

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

The description states a specific verb (Create) and resource (external squad) plus the underlying route POST /api/external-squads, so an agent knows exactly what the tool does. It does not, however, distinguish this from neighboring tools such as external_squad_update_external_squad or internal_squad_create_internal_squad.

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 exclusions. The only signal is the raw HTTP verb/route, which the agent must interpret on its own.

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. It states the HTTP method and route (which implies destructive mutation) but doesn't disclose what is destroyed, whether deletion is reversible, cascade effects on squad members, or permission requirements. The confirm gating appears only in the schema, not the description.

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?

Very short but wastes lines on redundant metadata: 'Delete external squad' restates the tool name, and 'Tags: External Squads Controller' is HTTP client boilerplate rather than useful agent-facing context. The route line is the only genuinely informative part.

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 deletion tool with no annotations and no output schema, the description is inadequate: no confirmation of irreversible effects, no cascade/member implications, no error or not-found behavior. The schema's confirm field hints at a safety flow but the description never explains 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% – both the uuid and confirm parameters have descriptions in the schema, including the important confirm-preview behavior. The description adds no parameter meaning beyond what the schema already provides, 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?

States a specific verb (Delete) and resource (external squad) plus the exact route DELETE /api/external-squads/{uuid}. Siblings like external_squad_get_external_squads and external_squad_update_external_squad are implicitly distinguished by the verb, though the description doesn't explicitly contrast 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 when-to-use guidance, prerequisites, or alternatives named. The confirm parameter implies a preview-then-confirm flow, but the tool description itself doesn't explain when to call this versus related tools like external_squad_remove_users_from_external_squad.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only echoes the route signature. The HTTP verb implies a read, but there is no statement about authentication requirements, error behavior for unknown UUIDs, or whether the response is cached/partitioned.

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

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

It is short and front-loaded, but the trailing "Tags: External Squads Controller" is classifier noise with no value to an agent, and the raw route line duplicates information already conveyed by the name.

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

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

For a single-parameter GET with no output schema, the description is only barely sufficient — it confirms this returns one squad identified by UUID. It omits return-shape hints and failure modes, which an agent would need to plan around.

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 fully documented in the schema, so the baseline is 3. The description's "{uuid}" path token adds no meaning beyond what the schema already states.

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

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

"Get external squad by uuid" names a verb and resource and the identifying key, so the intent is unambiguous, but it is nearly a verbatim restatement of the tool name and adds nothing about what an 'external squad' is. No differentiation from the sibling external_squad_get_external_squads (list all) is offered.

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

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

There is no when-to-use guidance at all. The description never says when to fetch a single squad versus the collection endpoint, nor mentions any precondition (squad must exist, valid UUID).

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

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

No annotations are supplied, so the description carries the full behavioral burden, yet it only dumps the raw HTTP method/path. It does not state pagination behavior, result ordering, auth/permission requirements, or whether the full squad list is returned. "GET" implies a safe read, but nothing is explicitly disclosed.

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

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

The description is short and front-loads the intent, but it wastes space on a raw REST path and a "Tags: External Squads Controller" artifact that add no meaning for an agent. The useful content is a single clause.

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

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

For a zero-argument list tool this is minimally adequate, but with no annotations and no output schema the description should at least indicate whether the response is paginated or filtered, which it omits. It leaves the agent guessing about the shape and size 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 tool takes zero parameters, which is the baseline-4 case; there is nothing for the description to explain beyond what the empty schema already communicates.

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 says "Get all external squads", which names the resource and the list-all scope, but it largely restates the tool name and gives no differentiation from the sibling external_squad_get_external_squad_by_uuid or from internal_squad_get_internal_squads. An agent gets the gist but must infer how it relates to its siblings.

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

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

There is no guidance on when to use this versus get_external_squad_by_uuid or the internal-squad equivalents, nor any prerequisite or filtering context. Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description carries the full burden. It does not state whether this requires authentication, whether results are paginated, what the response shape is, or any rate limits. 'Get' implies read-only but nothing beyond that is disclosed.

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

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

It is short and front-loaded, but includes redundant boilerplate: the raw GET path and 'Tags: External Squads Controller' add no agent-facing 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-param, no-annotation, no-output-schema tool, the description is minimal. It doesn't explain what 'tags' means in this domain (the set of tags used by external squads) or how it differs from the sibling external_squad_get_external_squads endpoint, leaving the agent without enough context to choose it confidently.

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, so the baseline is 4. The description correctly implies no input is required.

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

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

The description states 'Get tags of External Squads', which is a clear verb+resource, but it is partially a restatement of the tool name and does not distinguish it from similar tag-fetching siblings like internal_squad_get_tags, hosts_get_hosts_tags, or config_profile_get_tags. The raw GET path adds little semantic value.

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 the many other *_get_tags siblings. No context, prerequisites, or alternatives are mentioned.

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

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

With no annotations, the description carries the full behavioral burden, yet it only restates the HTTP call. It omits that the operation is destructive/bulk, whether removals are reversible, what permissions are needed, and — most importantly — the preview-only behavior when confirm is absent (that detail exists only in a Russian-language schema description).

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?

Very short and front-loaded with the verb and resource, but the raw HTTP path and the 'Tags: External Squads Controller' line are autogenerated noise that consumes part of an already minimal description.

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, unannotated bulk mutation with no output schema, the description should explain the confirmation/preview flow and what 'remove users' operates on. Neither appears, so an agent could invoke it without realizing the call is a dry run and may be missing a user-list argument.

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 baseline 3 applies; the uuid and confirm parameters are documented in the schema. However, the description adds nothing beyond the endpoint, and it is silent on how the target users are identified for a 'remove-users' bulk endpoint, which is not clarified anywhere in either field.

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

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

States a specific verb and resource ('Delete users from external squad') and includes the exact HTTP method and path, so the action is unambiguous. It does not explicitly distinguish itself from close siblings like external_squad_delete_external_squad (whole squad) or internal_squad_remove_users_from_internal_squad, though the name and path make the scope inferable.

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

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

No guidance on when to use this versus external_squad_update_external_squad or the add-users counterpart, and no mention that this is a bulk operation requiring a user list. The critical precondition that confirm:true must be passed for the request to actually execute is never surfaced in the description.

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

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

No annotations are provided, so the description carries the full burden. The 'POST' prefix implies mutation, but the description does not disclose what gets destroyed, whether the item list must be exhaustive, whether omitted squads lose their position, or what authorization is required. The confirm-parameter behavior is documented in the schema, not the description.

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 short and front-loads the method and route, but the trailing 'Tags: External Squads Controller' is auto-generated filler that adds no value, and the core purpose line is a bare restatement with no detail.

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

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

For a mutation tool with nested object parameters, no annotations, and no output schema, the description is inadequate. It omits payload semantics, ordering behavior, and error/confirmation expectations that an agent would need to invoke it correctly.

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

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

Schema coverage is 50%: only the confirm parameter is described in the schema, while the nested body/items structure (uuid + viewPosition) is undocumented. The description adds nothing about how to construct the reorder payload, so it fails to compensate for the coverage gap.

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

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

States a specific verb (reorder) and resource (external squads), which is enough to distinguish it from the get/create/delete external squad siblings. However, it never explains what reordering means operationally (view positions), so the agent must infer intent from the name alone.

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

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

The description gives no when-to-use guidance, no prerequisites, and no mention of the sibling reorder tools (internal_squad_reorder_internal_squads, config_profile_reorder_config_profiles). The only context is the HTTP verb and route.

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, and it discloses almost nothing. It does not state that tags are fully replaced, whether the operation is idempotent, what permissions are required, or the fact that a confirm:true flag gates actual execution. The PATCH keyword vs the 'Set tags' wording also leaves the replace-vs-merge semantics ambiguous.

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

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

It is short, but a full third of the content ('Tags: External Squads Controller') is a doc-generator artifact that carries no meaning, and the leading HTTP method/URL duplicates information an agent can infer from the name. Front-loading is undermined by the low-value raw endpoint string.

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 nested-body mutation tool with a confirm-gated preview mechanism, no annotations, and no output schema, the description is far too thin. It omits the confirm/preseview contract, replacement semantics, and any return information, leaving the agent unable to call it confidently.

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 only 50%, and the description adds no parameter meaning at all. It does not explain the uuid target, the tags array constraints (10 items, 36-char pattern), or the preview/confirm behavior of the confirm flag, all of which matter for correct invocation.

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

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

The phrase 'Set tags of External Squad' gives a clear verb and resource, so an agent knows exactly what the tool mutates. However, it does not differentiate itself from near-identical siblings like internal_squad_set_tags, node_plugin_set_tags, or config_profile_set_tags, which all share the same 'set tags' verb pattern. The 'PATCH /api/external-squads/tags' header is redundant restatement.

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 external_squad_get_tags (read) or external_squad_update_external_squad (general update). No prerequisites, no note that it likely replaces the entire tag set rather than appending. The agent is left to infer usage entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about auth requirements, partial-update semantics, or reversibility. The important confirm/preview gate is only documented inside the schema (in Russian), not the description.

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

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

It is short, but 'Tags: External Squads Controller' is auto-generated noise that does not earn its place, and nothing useful is front-loaded before it.

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 a deeply nested body, no annotations, no output schema, and a confirmation gate, this description is far too thin. An agent cannot determine correct invocation behavior without opening the schema.

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

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

With only 50% schema description coverage and two parameters, the description adds no meaning for any field. The large nested body (templates, hwidSettings, customRemarks, etc.) is left entirely to the schema with no descriptive compensation.

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 'Update external squad' is essentially a restatement of the tool name (external_squad_update_external_squad). Beyond the HTTP verb PATCH, it adds no resource scope or differentiation from siblings like external_squad_create_external_squad or internal_squad_update_internal_squad.

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 external_squad_get_external_squad_by_uuid or the create/delete variants. The 'Update' verb implies a mutation but no context, prerequisites, or exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses nothing beyond the endpoint. It does not say the deletion is irreversible/destructive, that it is a bulk mutation, or how the confirm flag gates execution (preview vs. actual send) — that safety-relevant behavior is buried in the schema field description, not the tool description.

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

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

The single operative sentence is front-loaded and waste-free, but the leading HTTP verb/path and trailing 'Tags: Hosts Bulk Actions Controller' line are framework boilerplate that consume space without helping an agent decide or invoke.

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 mutation with a nested request body, no annotations, and no output schema, the description is thin: it omits reversibility, the confirm/preview mechanic, partial-failure semantics, and any return expectations. An agent has enough to guess the call but not enough to use it safely.

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

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

Schema coverage is 50%: the nested 'confirm' boolean is documented in the schema, but the 'uuids' array has no field-level description. The phrase 'by UUIDs' conveys the key input's meaning, so the description breaks even with the schema baseline without adding format, limits, or behavior for confirm.

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

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

States a specific verb and resource ('Delete hosts by UUIDs'), which distinguishes it from the single-host sibling hosts_delete_host and from hosts_bulk_actions_disable_hosts/enable_hosts. It never explicitly names those siblings, so it falls short of a 5, and the raw HTTP path/tag line adds noise rather than clarity.

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

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

There is no when-to-use guidance, no statement of when to prefer this over hosts_delete_host (single) or the other bulk host actions, and no prerequisites called out. The description only asserts what the endpoint does, leaving selection entirely to inference from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the HTTP verb/path. It does not state whether disabling is reversible, whether it affects active connections/subscriptions, what permissions are required, or how many UUIDs can be processed at once. The confirm/preview behavior is not surfaced, though the schema does cover the confirm parameter.

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?

Very short and front-loaded, with the action stated immediately. The raw 'POST /api/hosts/bulk/disable' line and the 'Tags: ...' controller line are boilerplate that contribute little to tool selection, keeping it from a 5.

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

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

For a destructive bulk mutation with no annotations and no output schema, the description is thin: it omits reversibility, side effects on live hosts/connections, and any warning about the preview/confirm gate. The nested body object and confirm semantics are left entirely to the schema, leaving real gaps for correct invocation.

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

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

Schema description coverage is 50%, and the one undocumented parameter (uuids) is the one the description gestures at with 'by UUIDs'. That adds marginal meaning beyond the schema's bare UUID-pattern array, but it supplies no limits, ordering, or duplicate-handling semantics. 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 gives a specific verb and resource: 'Disable hosts by UUIDs', which cleanly separates this tool from hosts_bulk_actions_enable_hosts, hosts_bulk_actions_delete_hosts and hosts_bulk_actions_set_port_to_hosts. It stops short of explicitly naming those siblings, so an agent relies on tool names rather than text to disambiguate.

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

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

There is no statement of when to use this bulk-disable operation versus disabling hosts individually (hosts_update_host) or via other bulk actions. The 'Tags:' and controller lines are provenance metadata, not usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the HTTP route and verb. It does not disclose the consequence of enabling (e.g., effect on already-enabled hosts), whether the operation is reversible, or that confirm:true is required for this non-GET call.

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

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

Very short and front-loaded with the endpoint and action, wasting no words on the core intent. The trailing "Tags: Hosts Bulk Actions Controller" line is metadata noise for an agent, which keeps it from a 5.

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

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

For a bulk mutation tool with no annotations and no output schema, the description should disclose effect, prerequisites, and the confirm requirement, but it only gives the route and verb. It is minimally adequate but leaves meaningful gaps an agent would need to resolve.

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 50%: the confirm parameter is documented in-schema, while the uuids parameter is not. The phrase "by UUIDs" maps to and mildly clarifies the required uuids array, but adds no format or batch-size detail, so the description only partially compensates for the coverage gap.

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

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

States a specific verb and resource ("Enable hosts") plus the selection mechanism ("by UUIDs"), so an agent can distinguish it from hosts_bulk_actions_disable_hosts and hosts_bulk_actions_delete_hosts by the verb alone. It does not explicitly name or contrast with those siblings, keeping it below 5.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives such as a single-host update. The agent is told what the endpoint does but not under what circumstances to choose 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 for a multi-host mutation. It discloses nothing about permissions, reversibility, partial-failure behavior, or the confirm/preview gate (that detail lives only in the schema's 'confirm' description). Only the bare PATCH/update semantics are conveyed, which the name already 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?

It is short and front-loads the endpoint, but the brevity is under-specification rather than disciplined conciseness. The 'Tags:' line is metadata boilerplate that does not help an agent decide or call correctly.

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 high-complexity bulk mutation with a deeply nested body, no output schema, and no annotations, the description is far too thin. An agent cannot safely determine scope, side effects, or required confirmation from this text alone.

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

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

The description adds no meaning for either parameter. With only 50% schema description coverage and a large nested 'body' object (mapper, internalSquads, subscriptions, etc.), the description should compensate but does not, leaving the complex override/mapper payload entirely to the schema. Note the schema itself does document parts of the body richly, but the description text contributes nothing.

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 verb and resource ('Update many hosts') plus the raw PATCH endpoint, so the intent is identifiable. However, it never clarifies that this sets specific host properties (e.g. port/sni/address) in bulk, nor distinguishes it from siblings like hosts_update_host, hosts_bulk_actions_disable_hosts, or hosts_bulk_actions_delete_hosts. The tool name ('set_port_to_hosts') actually narrows scope more than the description 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?

There is no guidance on when to use this bulk endpoint versus the single-host update (hosts_update_host) or the other bulk actions. No prerequisites, no conditions, no alternatives are named. The agent is left to infer everything from the name and HTTP path.

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

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

No annotations are provided, so the description carries the full burden, and it discloses almost nothing: it says the operation is a POST create but not that it is a write/mutation, what permissions are required, or that a confirmation gate (confirm) applies. For a create operation with a deeply nested, complex body, 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?

It is short, but the brevity is under-specification rather than conciseness. The valuable content is one line; the route and "Tags: Hosts Controller" fragments add no decision-relevant information and only pad the string.

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 a large nested input object, no annotations, and no output schema, the description should at least describe the create semantics and confirmation behavior. It leaves the agent without enough context to call the tool confidently beyond the bare verb.

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 50%; only the confirm parameter is documented (in the schema, not the description). The description adds zero parameter meaning, and does not explain the required body envelope or its key sub-objects (inbound, mapper, internalSquads) despite their complexity.

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 host") and the underlying route POST /api/hosts makes the mutation unambiguous. It distinguishes itself from hosts_update_host / hosts_delete_host by name alone, but adds no scope or context about what a host is or how it relates to inbounds/config profiles.

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

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

There is no when-to-use guidance, no prerequisites (e.g. needing a config profile inbound UUID first), and no mention of alternatives such as hosts_update_host or hosts_bulk_actions_*. The agent must infer everything from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose that deletion is irreversible, whether related configs/subscriptions are affected, or what authorization is required. The confirm/preview behavior exists only in the schema, not the description.

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 text is short and front-loaded with the action, but the 'DELETE /api/hosts/{uuid}' line largely restates the name and 'Tags: Hosts Controller' is generated boilerplate that earns no 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 destructive mutation with no annotations and no output schema, the description is too thin. It should convey irreversibility, side effects, and the confirm-gated preview flow, none of which appear.

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 50%: uuid has only format/pattern with no prose, and confirm's meaning lives in the schema itself. The description adds nothing beyond echoing '{uuid}', so it does not compensate for the undocumented uuid 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 and resource: 'Delete a host by UUID', and the REST path 'DELETE /api/hosts/{uuid}' reinforces it. However, it offers no differentiation from siblings like hosts_bulk_actions_delete_hosts or hosts_create_host, leaving the agent to infer the singular-vs-bulk distinction from the name alone.

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

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

There is no guidance on when to use this tool versus the bulk delete sibling, nor any mention of prerequisites or when-not-to-use conditions. The agent must infer that this deletes exactly one host.

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, yet it discloses no behavioral traits at all: no auth requirements, no pagination/limit behavior, no scope of what 'hosts' includes, no result expectations. 'GET /api/hosts' plus a controller tag restates the name rather than adding 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?

It is short and front-loaded, but two of the three lines are generated boilerplate ('GET /api/hosts', 'Tags: Hosts Controller') that add no decision-relevant information. Efficient in size, thin in substance.

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 tool with no output schema and no annotations, the description should at least convey what is returned or whether results are filtered/paginated. It does neither, leaving the agent guessing about return shape and scope.

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

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

The tool takes zero parameters, so there are no parameter semantics to clarify; the baseline of 4 applies. Nothing in the description misleads about inputs.

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

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

The description gives a verb+resource ('Get hosts') plus the raw endpoint, so the basic purpose is identifiable. However, it offers nothing to distinguish it from close siblings like hosts_get_one_host or hosts_get_hosts_tags beyond the plural noun. It is minimally viable rather than descriptive.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no reference to the alternative sibling tools for fetching a single host or host tags. The listing use case is only weakly implied by the plural 'hosts'.

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

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

With no annotations, the description carries the full behavioral burden, yet it only restates the HTTP method and controller. It does not state that this is a safe read, whether results are paginated, or what the tag 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?

Very short and front-loaded with the operation, so nothing is buried. The trailing 'Tags: Hosts Controller' line is generated metadata noise rather than useful content, which keeps it out of the top band.

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 tool with no output schema, the description tells the agent what is retrieved but not the return shape (e.g., a list of tag strings) or any grouping/ordering. Adequate but with a clear gap.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description correctly implies a parameterless call with no filtering.

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

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

States a specific verb and resource ('Get tags of hosts') plus the underlying endpoint, which is enough to tell it apart from the many sibling tag endpoints (nodes_get_nodes_tags, users_get_users_tags, config_profile_get_tags) since it is scoped to hosts. It is clear, though it does not explicitly call out those siblings.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative. The purpose implies the usage context (listing the tag vocabulary for hosts), but an agent gets no help distinguishing it from the other 'get tags' tools in the sibling list.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing beyond the HTTP endpoint. Auth requirements, error behavior for a missing/unknown UUID, and return shape are all unstated.

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

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

Three short lines, front-loaded with the operative meaning; the raw endpoint path and "Tags: Hosts Controller" are spec boilerplate but not actively harmful.

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

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

With no annotations and no output schema, the description should say more about the returned host object and any access constraints. For a single-resource fetch it leaves the agent guessing about failure modes and response content.

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 is covered by the schema's type, format, and pattern, though schema description coverage is 0%. "By UUID" confirms the parameter's meaning but adds nothing about where the UUID comes from or what happens if it does not 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?

"Get a host by UUID" names a specific verb and resource, and the "by UUID" qualifier separates it from the list tool hosts_get_hosts. It never explicitly names or contrasts with a sibling, but the scope is unambiguous.

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

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

There is no guidance on when to use this versus hosts_get_hosts, hosts_get_hosts_tags, or the single-host retrieval alternatives. The agent must infer usage purely from the name.

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

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

No annotations are provided, so the description carries the full burden. "POST" implies a mutation, but nothing is disclosed about what is changed, whether ordering is global or scoped, side effects on existing hosts, or permissions required. The confirm/preview behavior is only documented in the schema in Russian, not in the description.

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

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

It is short, but the content is an unedited OpenAPI dump: an HTTP method plus path and a "Tags: Hosts Controller" line that carries no meaning for an agent. The useful statement ("Reorder hosts") is present but there is no restructuring or added value, so brevity comes from under-specification rather than 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 a nested-object body, a confirmation parameter, no annotations, and no output schema, the description is completely inadequate. It gives the agent nothing beyond the endpoint signature to call this mutation tool correctly.

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

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

Schema description coverage is only 50% — the nested body.hosts array (uuid + viewPosition pairs) is undocumented, and the description adds nothing about it. The one documented parameter (confirm) is described only in the schema, not the description, so the description does not compensate for the coverage gap on a complex nested payload.

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?

"Reorder hosts" names a verb and a resource, so the basic operation is inferable, but it is essentially the tool name normalized (hosts_reorder_hosts → Reorder hosts). It offers no scope detail — what ordering means, whether it affects view order globally, or how it differs from hosts_update_host or the other reorder_* sibling tools.

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

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

There is no when-to-use guidance at all. The agent is not told when reordering hosts is appropriate, what prerequisites exist (e.g., that hosts must exist), or how this relates to the similarly named reorder tools for nodes, squads, or config profiles.

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

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

No annotations are provided, so the description carries the full behavioral burden. It reveals only that the operation is a PATCH (mutating), but says nothing about permissions, whether fields are merged or replaced, the partial-update semantics, or the confirm/preview workflow. For a mutation tool with zero annotation coverage this is a significant gap.

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

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

Three terse lines with the HTTP method front-loaded and no wasted words, so it is structurally clean. But the brevity reflects under-specification rather than disciplined conciseness for a tool this complex.

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

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

This is a complex host-update tool with a deeply nested schema, no annotations, and no output schema. The description provides none of the context an agent needs about merge behavior, the mapper-rewrite mechanism, or the preview-then-confirm flow, leaving it far short of 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?

With only 50% schema description coverage and a large nested body (mapper with base64/mihomo/singbox/xrayJson operations, internalSquads, inbound, etc.), the description adds zero meaning about any parameter. It does not explain the required uuid, which fields are optional, or the required confirm flag described only inside 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 states a verb and resource ('Update a host') and discloses the endpoint (PATCH /api/hosts), so the basic purpose is clear and distinguishes it from siblings like hosts_create_host or hosts_delete_host by implication. However, it is essentially a restatement of the tool name with no elaboration on what 'update' covers, making it minimum-viable rather than genuinely clarifying.

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

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

There is no when-to-use guidance, no mention of prerequisites (e.g., host must exist), and no routing to alternatives such as hosts_bulk_nodes_update or hosts_create_host. The agent is left to infer usage purely from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says nothing about the mutation's effects (e.g. duplicate HWID handling), permission requirements, or the confirm/preview gate described only in the schema, leaving key behavioral traits undisclosed for a state-changing 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 text is short but poorly spent: the raw 'POST /api/hwid/devices' line and 'Tags: ...' metadata consume most of it while conveying nothing the agent can act on. This is under-specification rather than effective 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 mutating tool with a nested seven-field body, no annotations, no output schema, and no usage guidance, the description is far too thin. An agent cannot confirm the write semantics, the confirm gate, or how to handle duplicates from this text 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?

Schema description coverage is only 50%, and the description adds no parameter meaning at all. The nested body object (hwid pattern, required userId, optional platform/osVersion/requestIp/userAgent/deviceModel) is left entirely to the schema, and the confirm preview behavior is documented only 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?

The description states a clear verb and resource ('Create a user HWID device'), which tells the agent this is the write counterpart to the hwid_user_devices_get_* and delete_* siblings. However, 'POST /api/hwid/devices' is pure noise and the sentence merely restates the tool name without adding scope or distinguishing detail 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?

There is no guidance on when to use this tool versus alternatives such as hwid_user_devices_get_user_hwid_devices or delete_user_hwid_device, nor any prerequisite or precondition (e.g. that the target user must exist). Usage must be fully inferred from the name.

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

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

With no annotations provided, the description carries the full burden, yet it only restates the operation and endpoint. It never discloses that this is an irreversible bulk destruction, what permissions are required, or the confirm:true preview behavior (which it leaves to the schema). For a destructive operation with zero annotation coverage this is a significant gap.

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

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

It is very short and front-loads the operation, but two of the three lines (the raw 'POST /api/...' path and the 'Tags: HWID User Devices Controller' boilerplate) are auto-generated noise that adds no decision 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 destructive, non-GET bulk operation with no annotations and no output schema, the description is under-specified: it omits irreversibility, scope, and the confirm/preview workflow needed to call it safely. The 50% parameter coverage gap is also left unaddressed.

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

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

Schema coverage is 50%: the confirm parameter is well documented, but body.userId is undocumented. The description adds no parameter meaning beyond the schema — it never clarifies that userId selects which user's devices are wiped, nor how the confirm preview interacts with the request.

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

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

The description states a specific verb and resource: 'Delete all user HWID devices', plus the underlying endpoint POST /api/hwid/devices/delete-all. The word 'all' implicitly distinguishes it from the single-device sibling hwid_user_devices_delete_user_hwid_device, though it never names that sibling. Clear purpose, but no explicit sibling differentiation.

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

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

There is no guidance on when to use this bulk delete versus the single-device delete sibling, nor any stated prerequisite (permissions, confirm flow). The agent must infer usage entirely from the name. This is the minimum guidance level, not explicit 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 full behavioral burden. It says 'Delete' but does not disclose irreversibility, required permissions, or side effects on the user's device limit. The confirm/preview mechanism is documented only in the schema parameter, not in the description.

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?

Purpose is front-loaded and the text is short, but it wastes a line on the auto-generated 'Tags: HWID User Devices Controller' and the raw HTTP method/path, neither of which helps an agent decide or invoke. Appropriately sized but not fully earning its space.

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

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

For a destructive mutation with no annotations, no output schema, and a nested undocumented body, the description should explain the confirm gate, irreversibility, and the target identifiers. It supplies only the action, leaving key invocation context to the schema alone.

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

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

Schema description coverage is 50% – the 'confirm' parameter is documented, but the nested body fields (userId, hwid) carry no descriptions anywhere. The description mentions no parameters at all, so it adds zero meaning to the userId/hwid identifiers it requires.

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

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

States a specific verb+resource: 'Delete a user HWID device'. The singular 'a user HWID device' implicitly distinguishes it from the sibling hwid_user_devices_delete_all_user_hwid_devices, but the description never names that sibling or makes the contrast explicit. Clear purpose, no explicit sibling differentiation.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as the delete-all or create-device siblings. The agent gets the endpoint and the action, but nothing about which conditions select this tool over its near neighbors.

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 burden. It usefully discloses that filters use expensive LIKE operators and can degrade database performance, which is genuine behavioral context, and that pagination is via start/size. It omits confirmation that this is a read-only listing, auth requirements, and the shape/volume of returned data.

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 functional core is front-loaded, but there is redundancy (HTTP path line plus 'Get HWID devices') and non-earning chrome such as the 'Tags: HWID User Devices Controller' line. A Russian-language pagination sentence amid otherwise English text also hurts scannability.

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 6 parameters (several nested), no output schema, and no annotations, the description should carry substantial weight but does not. It explains neither the return payload nor the structure of filters/sorting/filterModes/globalFilterMode, so an agent lacks the detail needed to invoke it confidently.

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